pax_global_header00006660000000000000000000000064135716533200014517gustar00rootroot0000000000000052 comment=6a1f16645a0c336d3cd42f33890e357e0fd13091 atd-2.1.0/000077500000000000000000000000001357165332000122675ustar00rootroot00000000000000atd-2.1.0/.agignore000066400000000000000000000000311357165332000140550ustar00rootroot00000000000000*.expected.mli? expected/atd-2.1.0/.gitignore000066400000000000000000000003661357165332000142640ustar00rootroot00000000000000*~ *.cmi *.cmo *.cmx *.cma *.cmxa *.cmxs *.a *.o *.annot *.run *.opt *.exe _build .merlin *.install META atd_doc_lexer.ml atd_lexer.ml atd_parser.ml atd_parser.mli atd_version.ml unit-tests dep *.out html man1 *.cm[ioxa] *.cmx[as] *.[oa] *.annot atd-2.1.0/.ocp-indent000066400000000000000000000015721357165332000143350ustar00rootroot00000000000000# See https://github.com/OCamlPro/ocp-indent/blob/master/.ocp-indent for more # Indent for clauses inside a pattern-match (after the arrow): # match foo with # | _ -> # ^^^^bar # the default is 2, which aligns the pattern and the expression match_clause = 4 # When nesting expressions on the same line, their indentation are in # some cases stacked, so that it remains correct if you close them one # at a line. This may lead to large indents in complex code though, so # this parameter can be used to set a maximum value. Note that it only # affects indentation after function arrows and opening parens at end # of line. # # for example (left: `none`; right: `4`) # let f = g (h (i (fun x -> # let f = g (h (i (fun x -> # x) # x) # ) # ) # ) # ) max_indent = 2 atd-2.1.0/CHANGES.md000066400000000000000000000022661357165332000136670ustar00rootroot000000000000002.1.0 (2019-12-3) ----------------- * Fix bug preventing generated code from compiling when using json adapters on recursive types. * Improve automatic error messages shown in case of failed validation. Now include the validator's name or code. * Add support for json adapters in the bucklescript backend. (#153) 2.0.0 (2018-05-31) ------------------ * Add support for json adapters in OCaml (``) * Add support for json enums with a catch-all case (``) * Remove `` and `` 1.13.0 (2018-03-27) ------------------- * Introduce `atdgen-runtime` package. This package contains the runtime dependency introduced by the `atdgen` code generator. The old runtime library is deprecated * Add `atdj` to set of released packages. `atdj` is a java code generator for .atd files. * Improve generated code to emit ppx attributes to ignore harmless warnings * `Ag_version` submodule has been replaced with `Version`. * Transition `atd` aliases using the `(wrapped true)` mode of jbuilder. This is a breaking change for all of those who use `atd` the library. All modules are now accessible under the `Atd.` entry module. atd-2.1.0/CODEOWNERS000066400000000000000000000023151357165332000136630ustar00rootroot00000000000000# This file determines who will be assigned code reviews by Github. # See https://help.github.com/articles/about-codeowners/ # We are looking for volunteers to help with project maintenance. # Please open an pull request or an issue indicating your skills and interests. # # We can use help with the following: # - triaging issues: answering questions of fellow users, # asking for clarification on how to reproduce a bug, assigning issues # to a suitable team member. # - documentation: adding examples based on your practical use cases. # - tooling: if you're familiar with a particular tool that would be useful # to the project, please use your expertise and help us get set up. # - community: let the world know your organization depends on the project, # help us get more users, weigh in on design decisions. # Fallback reviewers * @mjambon @rgrinberg # ATD language /atd/ @mjambon /atdcat/ @mjambon # OCaml and Bucklescript support /atdgen-runtime/ @rgrinberg @mjambon /atdgen/ @rgrinberg @mjambon # Bucklescript-specific files obuckle_* @rgrinberg bucklescript/ @rgrinberg *_bs* @rgrinberg # Java support # /atdj/ YOUR_NAME_HERE # Scala support /atds/ @aij # Use of the dune build system dune* @rgrinberg atd-2.1.0/LICENSE.md000066400000000000000000000025511357165332000136760ustar00rootroot00000000000000Copyright (c) 2010 MyLife All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. The name of the author may not be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. atd-2.1.0/Makefile000066400000000000000000000011721357165332000137300ustar00rootroot00000000000000DUNE ?= dune all: $(DUNE) build test: $(DUNE) runtest check: test js: $(DUNE) build atdgen/bin/ag_main.bc.js clean: $(DUNE) clean all-supported-ocaml-versions: $(DUNE) runtest --workspace dune-workspace.dev doc: cd doc && sphinx-build . _build livedoc: cd doc && sphinx-autobuild . _build \ -p 8888 -q --host $(shell hostname) -r '\.#.*' package := atd opam-release: dune-release distrib --skip-build --skip-lint --skip-tests -n $(package) dune-release publish distrib --verbose -n $(package) dune-release opam pkg -n $(package) dune-release opam submit -n $(package) .PHONY: all test clean check doc livedoc atd-2.1.0/README.md000066400000000000000000000043521357165332000135520ustar00rootroot00000000000000ATD project - Static Types for Json APIs == ATD stands for Adaptable Type Definitions. It is a syntax for defining cross-language data types. It is used as input to generate efficient and type-safe serializers, deserializers and validators. The current target languages are OCaml and Java. The following opam packages are provided by the atd project: * atdgen: executable that generates OCaml code dealing with json and biniou data formats * atdj: executable that generates Java code dealing with json * atd: library for parsing atd files used by code generators Documentation -- [here](http://atd.readthedocs.io/) Help wanted -- The ATD suite of tools is developed and maintained by volunteers—users like you. [Various issues](https://github.com/mjambon/atd/issues) are in need of attention. If you'd like to contribute, please leave a comment on the issue you're interested in, or create a new issue. Experienced contributors will guide you as needed. There are many simple ways of making a positive impact. For example, you can... * Use the software in your project. * Give a demo to your colleagues. * Share the passion on your blog. * Tweet about what you're doing with atd. * Report difficulties by creating new issues. We'll triage them. * Ask questions on StackOverflow. * Answer questions on [StackOverflow](https://stackoverflow.com/search?q=atdgen). * Discuss usage on the [OCaml forums](https://discuss.ocaml.org/). * Pick a [task](https://github.com/mjambon/atd/issues) that's easy for you. Check out in particular [good first time issues](https://github.com/mjambon/atd/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+time+issue%22) and other issues with which [we could use some help](https://github.com/mjambon/atd/issues?q=is%3Aissue+is%3Aopen+label%3A%22help+wanted%22). See our [contribution guidelines](https://github.com/mjambon/documents/blob/master/how-to-contribute.md). Authors -- The ATD language and atdgen were originally created at MyLife by Martin Jambon in 2010. Atdj was created at MyLife by John Billings in 2010. Multiple volunteers contributed to the project after that. Other prominent contributors include Jeff Meister, David Sheets, and Rudi Grinberg. We distribute the source code under the terms of a BSD license. atd-2.1.0/atd.opam000066400000000000000000000026361357165332000137240ustar00rootroot00000000000000# This file is generated by dune, edit dune-project instead opam-version: "2.0" synopsis: "Parser for the ATD data format description language" description: """ ATD is the OCaml library providing a parser for the ATD language and various utilities. ATD stands for Adjustable Type Definitions in reference to its main property of supporting annotations that allow a good fit with a variety of data formats. """ maintainer: ["Rudi Grinberg "] authors: [ "Martin Jambon " "David Sheets " "Rudi Grinberg " "Ivan Jager " "Jeff Meister " "Carmelo Piccione " "Raman Varabets " "Mathieu Baudet " "Rauan Mayemir " "Louis Roché " "Brendan Long " "Christophe Troestler " "Vincent Bernardoff " "haoyang " ] license: "MIT" homepage: "https://github.com/ahrefs/atd" bug-reports: "https://github.com/ahrefs/atd/issues" depends: [ "ocaml" {>= "4.02"} "dune" {>= "1.11"} "menhir" "easy-format" "re" ] dev-repo: "git+https://github.com/ahrefs/atd.git" build: [ ["dune" "subst"] {pinned} [ "dune" "build" "-p" name "-j" jobs "@install" "@doc" {with-doc} ] ] atd-2.1.0/atd.opam.template000066400000000000000000000002171357165332000155270ustar00rootroot00000000000000build: [ ["dune" "subst"] {pinned} [ "dune" "build" "-p" name "-j" jobs "@install" "@doc" {with-doc} ] ] atd-2.1.0/atd/000077500000000000000000000000001357165332000130375ustar00rootroot00000000000000atd-2.1.0/atd/src/000077500000000000000000000000001357165332000136265ustar00rootroot00000000000000atd-2.1.0/atd/src/annot.ml000066400000000000000000000053451357165332000153060ustar00rootroot00000000000000(* Utilities for interpreting annotations of type Ast.annot. *) open Import type t = Ast.annot let error_at loc s = failwith (sprintf "%s:\n%s" (Ast.string_of_loc loc) s) let field ~section ~field l = let open Option.O in List.assoc section l >>= fun (_, l2) -> List.assoc field l2 let has_section k l = Option.is_some (List.assoc k l) let has_field ~sections:k ~field:k2 l = List.exists (fun k1 -> field ~section:k1 ~field:k2 l |> Option.is_some ) k let get_flag ~sections:k ~field:k2 l = k |> List.find_map (fun k1 -> field ~section:k1 ~field:k2 l |> Option.map (fun (loc, o) -> match o with | None | Some "true" -> true | Some "false" -> false | Some s -> error_at loc (sprintf "Invalid value %S for flag %s.%s" s k1 k2))) |> Option.value ~default:false let get_field ~parse ~default ~sections:k ~field:k2 l = k |> List.find_map (fun k1 -> let open Option.O in field l ~section:k1 ~field:k2 >>= fun (loc, o) -> match o with | Some s -> (match parse s with Some _ as y -> y | None -> error_at loc (sprintf "Invalid annotation <%s %s=%S>" k1 k2 s)) | None -> error_at loc (sprintf "Missing value for annotation %s.%s" k1 k2)) |> Option.value ~default let get_opt_field ~parse ~sections ~field l = let parse s = match parse s with | None -> None (* indicates parse error *) | Some v -> Some (Some v) in get_field ~parse ~default:None ~sections ~field l let set_field ~loc ~section:k ~field:k2 v l : Ast.annot = match List.assoc k l with | None -> (k, (loc, [ k2, (loc, v) ])) :: l | Some (section_loc, section) -> let section_loc, section = List.assoc_exn k l in let section = match List.assoc k2 section with | None -> (k2, (loc, v)) :: section | Some _ -> List.assoc_update k2 (loc, v) section in List.assoc_update k (section_loc, section) l let collapse merge l = let tbl = Hashtbl.create 10 in let n = ref 0 in List.iter ( fun (s1, f1) -> incr n; try let _, f2 = Hashtbl.find tbl s1 in Hashtbl.replace tbl s1 (!n, merge f1 f2) with Not_found -> Hashtbl.add tbl s1 (!n, f1) ) (List.rev l); let l = Hashtbl.fold (fun s (i, f) l -> (i, (s, f)) :: l) tbl [] in let l = List.sort (fun (i, _) (j, _) -> compare j i) l in List.map snd l let override_values x1 _ = x1 let override_fields (loc1, l1) (_, l2) = (loc1, collapse override_values (l1 @ l2)) let merge l = collapse override_fields l let create_id = let n = ref (-1) in fun () -> incr n; if !n < 0 then failwith "Annot.create_id: counter overflow" else string_of_int !n atd-2.1.0/atd/src/annot.mli000066400000000000000000000074771357165332000154670ustar00rootroot00000000000000(** Utilities for interpreting annotations of type {!Ast.annot} *) type t = Ast.annot (** Sample annotation in ATD syntax with legend: {v section a section b ----------- ------ | | | | | | | +- field without a value | | | | | +- field value | | | +- field name | +- section name v} The following rules must be followed for a proper use of this module: - There may not be two sections with the same name. The [merge] function can be used to merge sections. - Section order doesn't matter as long as section names are unique. - Field names within a section should be unique. If not, only the first occurrence of each field is meaningful. - Field values may be arbitrary strings. *) val has_section : string -> t -> bool (** Return true if such a section (first-level key) exists. *) val has_field : sections:string list -> field:string -> t -> bool (** [has_field section_names field_name annotations] returns true if at least one section exists with a name in [section_names] and one of its fields named [field_name]. Each section should be unique. *) val get_flag : sections:string list -> field:string -> t -> bool (** [get_flag section_names field_name] looks sequentially into the sections specified by [section_names] for a field named [field_name]. If no such field can be found in any section, the result is [false]. Otherwise, the search stops with the first field matching one of the section names and the field name. If the field has no associated value, the result is [true]. If the field value is ["true"] then [true] is returned. Likewise, if the field value is ["false"] then [false] is returned. If the field value is anything else, a [Failure] exception is raised. Each section should be unique. Given the following annotations in the ATD syntax noted [a]: {v v} We obtain the following results: {v # get_flag \["ocaml_312"; "ocaml"\] "openin" a;; \- : true # get_flag \["ocaml_311"; "ocaml"\] "openin" a;; \- : false # get_flag \["ocaml_312"\] "openin" a;; \- : true # get_flag \["ocaml_311"\] "openin" a;; \- : false # get_flag \["ocaml"\] "openin" a;; \- : false v} *) val get_field : parse:(string -> 'a option) -> default:'a -> sections:string list -> field:string -> t -> 'a (** [get_field parse default section_names field_name annotations] looks sequentially into the sections specified by [section_names] for a field named [field_name]. If no such field exists, the [default] value is returned. If the field is present, the associated value is parsed using the given function [parse] which should return [None] in order to indicate an invalid value. If the field is present without an associated value or if [parse] returns [None], a [Failure] exception is raised. Each section should be unique. *) val get_opt_field : parse:(string -> 'a option) -> sections:string list -> field:string -> t -> 'a option (** This is the same as [get_field] except that no default value for the field exists. *) val set_field : loc:Ast.loc -> section:string -> field:string -> string option -> t -> t (** [set_field loc section_name field_name value annotations] sets a field, reusing existing section [section_name] if it exists, preserving the position of field [field_name] and overwriting its value if it exists. *) val merge : t -> t (** Merge sections of the same name together, and keeps only the first occurrence of each field. {v v} becomes {v v} *) val create_id : unit -> string (** Create a unique numeric ID *) atd-2.1.0/atd/src/ast.ml000066400000000000000000000144121357165332000147510ustar00rootroot00000000000000open Import open Lexing type loc = Lexing.position * Lexing.position let dummy_loc = (Lexing.dummy_pos, Lexing.dummy_pos) exception Atd_error of string type full_module = module_head * module_body and module_head = loc * annot and module_body = module_item list and annot = annot_section list and annot_section = string * (loc * annot_field list) and annot_field = string * (loc * string option) and type_def = loc * (string * type_param * annot) * type_expr and module_item = | Type of type_def and type_param = string list and type_expr = | Sum of loc * variant list * annot | Record of loc * field list * annot | Tuple of loc * cell list * annot | List of loc * type_expr * annot | Option of loc * type_expr * annot | Nullable of loc * type_expr * annot | Shared of loc * type_expr * annot | Wrap of loc * type_expr * annot | Name of loc * type_inst * annot | Tvar of loc * string (* List, Option, Nullable, Shared and Wrap are the only predefined types with a type parameter (and no special syntax). *) and type_inst = loc * string * type_expr list and variant = | Variant of loc * (string * annot) * type_expr option | Inherit of loc * type_expr and cell = loc * type_expr * annot and field_kind = | Required | Optional | With_default and field = [ `Field of (loc * (string * field_kind * annot) * type_expr) | `Inherit of (loc * type_expr) ] let loc_of_type_expr = function | Sum (loc, _, _) | Record (loc, _, _) | Tuple (loc, _, _) | List (loc, _, _) | Option (loc, _, _) | Nullable (loc, _, _) | Shared (loc, _, _) | Wrap (loc, _, _) | Name (loc, _, _) | Tvar (loc, _) -> loc let set_type_expr_loc loc = function | Sum (_, a, b) -> Sum (loc, a, b) | Record (_, a, b) -> Record (loc, a, b) | Tuple (_, a, b) -> Tuple (loc, a, b) | List (_, a, b) -> List (loc, a, b) | Option (_, a, b) -> Option (loc, a, b) | Nullable (_, a, b) -> Nullable (loc, a, b) | Shared (_, a, b) -> Shared (loc, a, b) | Wrap (_, a, b) -> Wrap (loc, a, b) | Name (_, a, b) -> Name (loc, a, b) | Tvar (_, a) -> Tvar (loc, a) let string_of_loc (pos1, pos2) = let line1 = pos1.pos_lnum and start1 = pos1.pos_bol in Printf.sprintf "File %S, line %i, characters %i-%i" pos1.pos_fname line1 (pos1.pos_cnum - start1) (pos2.pos_cnum - start1) let error s = raise (Atd_error s) let error_at loc s = error (string_of_loc loc ^ "\n" ^ s) let annot_of_type_expr = function | Sum (_, _, an) | Record (_, _, an) | Tuple (_, _, an) | List (_, _, an) | Option (_, _, an) | Nullable (_, _, an) | Shared (_, _, an) | Wrap (_, _, an) | Name (_, _, an) -> an | Tvar (_, _) -> [] let map_annot f = function | Sum (loc, vl, a) -> Sum (loc, vl, f a) | Record (loc, fl, a) -> Record (loc, fl, f a) | Tuple (loc, tl, a) -> Tuple (loc, tl, f a) | List (loc, t, a) -> List (loc, t, f a) | Option (loc, t, a) -> Option (loc, t, f a) | Nullable (loc, t, a) -> Nullable (loc, t, f a) | Shared (loc, t, a) -> Shared (loc, t, f a) | Wrap (loc, t, a) -> Wrap (loc, t, f a) | Tvar _ as x -> x | Name (loc, (loc2, name, args), a) -> Name (loc, (loc2, name, args), f a) let rec amap_type_expr f = function | Sum (loc, vl, a) -> Sum (loc, List.map (amap_variant f) vl, f a) | Record (loc, fl, a) -> Record (loc, List.map (amap_field f) fl, f a) | Tuple (loc, tl, a) -> Tuple (loc, List.map (amap_cell f) tl, f a) | List (loc, t, a) -> List (loc, amap_type_expr f t, f a) | Option (loc, t, a) -> Option (loc, amap_type_expr f t, f a) | Nullable (loc, t, a) -> Nullable (loc, amap_type_expr f t, f a) | Shared (loc, t, a) -> Shared (loc, amap_type_expr f t, f a) | Wrap (loc, t, a) -> Wrap (loc, amap_type_expr f t, f a) | Tvar _ as x -> x | Name (loc, (loc2, name, args), a) -> Name (loc, (loc2, name, List.map (amap_type_expr f) args), f a) and amap_variant f = function Variant (loc, (name, a), o) -> let o = Option.map (amap_type_expr f) o in Variant (loc, (name, f a), o) | Inherit (loc, x) -> Inherit (loc, amap_type_expr f x) and amap_field f = function `Field (loc, (name, kind, a), x) -> `Field (loc, (name, kind, f a), amap_type_expr f x) | `Inherit (loc, x) -> `Inherit (loc, amap_type_expr f x) and amap_cell f (loc, x, a) = (loc, amap_type_expr f x, f a) let amap_module_item f (Type (loc, (name, param, a), x)) = Type (loc, (name, param, f a), amap_type_expr f x) let amap_head f (loc, a) = (loc, f a) let amap_body f l = List.map (amap_module_item f) l let map_all_annot f ((head, body) : full_module) = (amap_head f head, amap_body f body) let rec fold (f : type_expr -> 'a -> 'a) (x : type_expr) acc = let acc = f x acc in match x with Sum (_, variant_list, _annot) -> List.fold_right (fold_variant f) variant_list acc | Record (_, field_list, _annot) -> List.fold_right (fold_field f) field_list acc | Tuple (_, l, _annot) -> List.fold_right (fun (_, x, _) acc -> fold f x acc) l acc | List (_, type_expr, _annot) -> fold f type_expr acc | Option (_, type_expr, _annot) -> fold f type_expr acc | Nullable (_, type_expr, _annot) -> fold f type_expr acc | Shared (_, type_expr, _annot) -> fold f type_expr acc | Wrap (_, type_expr, _annot) -> fold f type_expr acc | Name (_, (_2, _name, type_expr_list), _annot) -> List.fold_right (fold f) type_expr_list acc | Tvar (_, _string) -> acc and fold_variant f x acc = match x with Variant (_, _, Some type_expr) -> fold f type_expr acc | Variant _ -> acc | Inherit (_, type_expr) -> fold f type_expr acc and fold_field f x acc = match x with `Field (_, _, type_expr) -> fold f type_expr acc | `Inherit (_, type_expr) -> fold f type_expr acc module Type_names = Set.Make (String) let extract_type_names ?(ignorable = []) x = let ign s = List.mem s ignorable in let add s set = if ign s then set else Type_names.add s set in let acc = fold ( fun x acc -> match x with Name (_, (_, name, _), _) -> add name acc | _ -> acc ) x Type_names.empty in Type_names.elements acc let is_parametrized x = fold (fun x b -> b || match x with Tvar _ -> true | _ -> false) x false let is_required = function | Optional | With_default -> false | Required -> true atd-2.1.0/atd/src/ast.mli000066400000000000000000000173051357165332000151260ustar00rootroot00000000000000(** Abstract syntax tree (AST) representing ATD data *) type loc = Lexing.position * Lexing.position (** A location in the source code. *) exception Atd_error of string (** Exception raised by functions of the [atd] library and indicating errors. *) type annot = annot_section list (** An annotation, consisting of a sequence of sections. {!Annot} provides utilities for handling annotations. *) and annot_section = string * (loc * annot_field list) (** represents a single annotation within edgy brackets. [<"foo" bar baz="123" path.to .thing="abc">] in ATD syntax translates to: {v ("foo", (loc1, [ ("bar", (loc2, None)); ("baz", (loc3, Some "123")); ("path.to.thing", (loc4, Some "abc")) ] )) v} *) and annot_field = string * (loc * string option) (** An annotation field, i.e. a key with an optional value within an annotation. *) type full_module = module_head * module_body (** Contents of an ATD file. *) and module_head = loc * annot (** The head of an ATD file is just a list of annotations. *) and module_body = module_item list (** The body of an ATD file is a list of type definitions. Type definitions are implicitely mutually recursive. They can be sorted based on dependencies using {!Atd.Util.tsort}. *) and module_item = | Type of type_def (** There is currently only one kind of module items, that is single type definitions. *) and type_def = loc * (string * type_param * annot) * type_expr (** A type definition. *) and type_param = string list (** List of type variables without the tick. *) and type_expr = | Sum of loc * variant list * annot | Record of loc * field list * annot | Tuple of loc * cell list * annot | List of loc * type_expr * annot | Option of loc * type_expr * annot | Nullable of loc * type_expr * annot | Shared of loc * type_expr * annot | Wrap of loc * type_expr * annot | Name of loc * type_inst * annot | Tvar of loc * string (** A type expression is one of the following: - [Sum]: a sum type (within square brackets) - [Record]: a record type (within curly braces) - [Tuple]: a tuple (within parentheses) - [List]: a list type written [list] with its parameter e.g. [int list] - [Option]: an option type written [option] with its parameter e.g. [string option] - [Nullable]: adds a null value to a type. [Option] should be preferred over [Nullable] since it makes it possible to distinguish [Some None] from [None]. - [Shared]: values for which sharing must be preserved. Such type expressions may not be parametrized. Values may only be shared if the source location of the type expression is the same. - [Wrap]: optional wrapping of a type. For example, a timestamp represented as a string can be wrapped within a proper time type. In that case, the wrapper would parse the timestamp and convert it into the internal representation of its choice. Unwrapping would consist in converting it back to a string. - [Name]: a type name other than [list] or [option], including the predefined types [unit], [bool], [int], [float], [string] and [abstract]. - [Tvar]: a type variable identifier without the tick *) and type_inst = loc * string * type_expr list (** A type name and its arguments *) and variant = | Variant of loc * (string * annot) * type_expr option | Inherit of loc * type_expr (** A single variant or an [inherit] statement. [Inherit] statements can be expanded into variants using {!Atd_inherit} or at loading time using the [inherit_variant] option offered by the {!Atd.Util} functions. *) and cell = loc * type_expr * annot (** Tuple cell. Note that annotations placed before the type expression are supported and represented here, such as the third cell in [(float * float * float)]. *) and field_kind = | Required | Optional | With_default (** Different kinds of record fields based on the - [Required]: required field, e.g. [id : string] - [Optional]: optional field without a default value, e.g. [?name : string option]. The ATD type of the field value must be an option type. - [With_default]: optional field with a default value, e.g. [~websites : string list]. The default value may be implicit or specified explicitely using annotations. Each target language that cannot omit fields may have to specify the default in its own syntax. Sample ATD file: {v type level = [ Beginner | Advanced | Expert ] type user = \{ id : string; ?name : string option; (* Field may be omitted when no value is set, if permitted by the target language. *) ~websites : string list; (* Implicit default: empty list. Field may be omitted if the field value is equal to the default value and the target language permits it. *) ~level : level; (* Explicit default for `ocaml'. For instance there is no `json' annotation because the default for undefined `JSON' fields would be to omit them. *) } v} *) and field = [ `Field of (loc * (string * field_kind * annot) * type_expr) | `Inherit of (loc * type_expr) ] (** A single record field or an [inherit] statement. [`Inherit] statements can be expanded into fields using {!Atd_inherit} or at loading time using the [inherit_fields] option offered by the {!Atd.Util} functions. *) val loc_of_type_expr : type_expr -> loc (** Extract the source location of any type expression. *) val set_type_expr_loc : loc -> type_expr -> type_expr (** Replace the location of the given expression. This is a shallow substitution. Sub-expressions are not affected. *) val string_of_loc : loc -> string (** Convert a location into a human-readable string such as [File "foo.atd", line 123, characters 40-45]. *) val error : string -> 'a (** [error s] is a shorthand for [raise (Atd_error s)]. *) val error_at : loc -> string -> 'a (** [error_at loc s] raises [Atd_error s'] where [s'] is the location followed by [s]. *) val dummy_loc : loc (** Dummy value for predefined constructs that are not associated with a useful source location. Should not show up in error messages. *) val annot_of_type_expr : type_expr -> annot (** Return the annotations associated with a type expression. Note that there can be annotations in a variety of places, not just after type expressions. *) val map_annot : (annot -> annot) -> type_expr -> type_expr (** Replacement of the annotations associated with a type expression. This is a shallow transformation. Sub-expressions are not affected. *) val map_all_annot : (annot -> annot) -> full_module -> full_module (** Replacement of all annotations occurring in an ATD module. *) val fold : (type_expr -> 'a -> 'a) -> type_expr -> 'a -> 'a (** Iteration and accumulation over each [type_expr] node within a given [type_expr]. *) val extract_type_names : ?ignorable : string list -> type_expr -> string list (** Extract all the type names occurring in a type expression under [`Name], without duplicates. @param ignorable specifies a list of type names to exclude from the result *) val is_parametrized : type_expr -> bool (** Test whether a type expression contains type variables ([`Tvar]). *) val is_required : field_kind -> bool atd-2.1.0/atd/src/check.ml000066400000000000000000000111361357165332000152370ustar00rootroot00000000000000(* Semantic verification *) open Import open Ast let add_name accu = function Name (_, (_, k, _), _) -> k :: accu | _ -> accu let get_kind = function Sum _ -> `Sum | Record _ -> `Record | _ -> `Other let check_inheritance tbl (t0 : type_expr) = let not_a kind _ = let msg = sprintf "Cannot inherit from non-%s type" (match kind with `Sum -> "variant" | `Record -> "record" | _ -> assert false) in error_at (loc_of_type_expr t0) msg in let rec check kind inherited (t : type_expr) = match t with Sum (_, vl, _) when kind = `Sum -> List.iter ( function Inherit (_, t) -> check kind inherited t | Variant _ -> () ) vl | Record (_, fl, _) when kind = `Record -> List.iter ( function `Inherit (_, t) -> check kind inherited t | `Field _ -> () ) fl | Sum _ | Record _ | Tuple _ | List _ | Option _ | Nullable _ | Shared _ | Wrap _ as x -> not_a kind x | Name (_, (loc, k, _), _) -> if List.mem k inherited then error_at (loc_of_type_expr t0) "Cyclic inheritance" else let (_arity, opt_def) = try Hashtbl.find tbl k with Not_found -> error_at loc ("Undefined type " ^ k) in (match opt_def with None -> () | Some (_, _, t) -> check kind (k :: inherited) t ) | Tvar _ -> error_at (loc_of_type_expr t0) "Cannot inherit from a type variable" in check (get_kind t0) (add_name [] t0) t0 let check_type_expr tbl tvars (t : type_expr) = let rec check : type_expr -> unit = function Sum (_, vl, _) as x -> List.iter (check_variant (Hashtbl.create 10)) vl; check_inheritance tbl x | Record (_, fl, _) as x -> List.iter (check_field (Hashtbl.create 10)) fl; check_inheritance tbl x | Tuple (_, tl, _) -> List.iter (fun (_, x, _) -> check x) tl | List (_, t, _) -> check t | Option (_, t, _) -> check t | Nullable (_, t, _) -> check t | Shared (loc, t, _) -> if Ast.is_parametrized t then error_at loc "Shared type cannot be polymorphic"; check t | Wrap (_, t, _) -> check t | Name (_, (loc, k, tal), _) -> assert (k <> "list" && k <> "option" && k <> "nullable" && k <> "shared" && k <> "wrap"); let (arity, _opt_def) = try Hashtbl.find tbl k with Not_found -> error_at loc ("Undefined type " ^ k) in let n = List.length tal in if arity <> n then error_at loc (sprintf "Type %s was defined to take %i parameters, \ but %i argument%s." k arity n (if n > 1 then "s are given" else " is given") ); List.iter check tal | Tvar (loc, s) -> if not (List.mem s tvars) then error_at loc (sprintf "Unbound type variable '%s" s) and check_variant accu = function Variant (loc, (k, _), opt_t) -> if Hashtbl.mem accu k then error_at loc (sprintf "Multiple definitions of the same variant constructor %s" k); Hashtbl.add accu k (); (match opt_t with None -> () | Some t -> check t) | Inherit (_, t) -> (* overriding is allowed, for now without a warning *) check t and check_field accu = function `Field (loc, (k, _, _), t) -> if Hashtbl.mem accu k then error_at loc (sprintf "Multiple definitions of the same field %s" k); Hashtbl.add accu k (); check t | `Inherit (_, t) -> (* overriding is allowed, for now without a warning *) check t in check t let check (l : Ast.module_body) = let predef = Predef.make_table () in let tbl = Hashtbl.copy predef in (* first pass: put all definitions in the table *) List.iter ( function Type ((loc, (k, pl, _), _) as x) -> if Hashtbl.mem tbl k then if Hashtbl.mem predef k then error_at loc (sprintf "%s is a predefined type, it cannot be redefined." k) else error_at loc (sprintf "Type %s is defined for the second time." k) else Hashtbl.add tbl k (List.length pl, Some x) ) l; (* second pass: check existence and arity of types in type expressions, check that inheritance is not cyclic *) List.iter ( function (Ast.Type (_, (_, tvars, _), t)) -> check_type_expr tbl tvars t ) l atd-2.1.0/atd/src/check.mli000066400000000000000000000004021357165332000154020ustar00rootroot00000000000000(** Check the validity of an ATD file beyond syntax. For example, this checks that each type definition is unique. *) (** Check the validity of an ATD file. Raises an exception on the first error encountered. *) val check : Ast.module_body -> unit atd-2.1.0/atd/src/doc.ml000066400000000000000000000026251357165332000147320ustar00rootroot00000000000000open Import type inline = Doc_types.inline = | Text of string | Code of string type block = Doc_types.block = | Paragraph of inline list | Pre of string type doc = block list let parse_text loc s = try (Doc_lexer.parse_string s : block list) with e -> failwith (Printf.sprintf "%s:\nInvalid format for doc.text %S:\n%s" (Ast.string_of_loc loc) s (Printexc.to_string e)) let get_doc loc an : doc option = Annot.get_opt_field ~parse:(fun s -> Some (parse_text loc s)) ~sections:["doc"] ~field:"text" an (* Conversion to HTML *) let html_escape buf s = String.iter ( function '<' -> Buffer.add_string buf "<" | '>' -> Buffer.add_string buf ">" | '&' -> Buffer.add_string buf "&" | '"' -> Buffer.add_string buf """ | c -> Buffer.add_char buf c ) s let print_inline buf = function | Text s -> html_escape buf s | Code s -> bprintf buf "%a" html_escape s let html_of_doc blocks = let buf = Buffer.create 300 in bprintf buf "\n
\n"; List.iter (function | Paragraph l -> Buffer.add_string buf "

\n"; List.iter (print_inline buf) l; Buffer.add_string buf "\n

\n" | Pre s -> Buffer.add_string buf "
\n";
        html_escape buf s;
        Buffer.add_string buf "
\n" ) blocks; bprintf buf "\n
\n"; Buffer.contents buf atd-2.1.0/atd/src/doc.mli000066400000000000000000000040421357165332000150760ustar00rootroot00000000000000(** Support for annotations: type foo = [ Bar of int ] This allows code generators to inject the documentation into the generated code. nodes that appear in the following positions should be taken into account by code generators that care about documentation: - after the type name on the left-hand side of a type definition - after the type expression on the right-hand side of a type definition (but not after any type expression) - after record field names - after variant names Formats: Currently only one format called "text" is supported: - Blank lines separate paragraphs. - [\{\{ \}\}] can be used to enclose inline verbatim text. - [\{\{\{ \}\}\}] can be used to enclose verbatim text where whitespace is preserved. - The backslash character is used to escape special character sequences. In regular paragraph mode the special sequences are [\ ], [\{\{] and [\{\{\{]. In inline verbatim text, special sequences are [\ ] and [\}\}]. In verbatim text, special sequences are [\ ] and [\}\}\}]. Character encoding: UTF-8 is strongly recommended, if not plain ASCII. *) type inline = | Text of string | Code of string (** [Text] is regular text. [Code] is text that was enclosed within [\{\{ \}\}] and should be rendered using the same fixed-width font used in all verbatim text. *) type block = | Paragraph of inline list | Pre of string (** [Paragraph] is a regular paragraph. [Pre] is preformatted text that was enclosed within [\{\{\{ \}\}\}] and should be rendered using a fixed-width font preserving all space and newline characters. *) type doc = block list (** A document is a list of paragraph-like blocks. *) val parse_text : Ast.loc -> string -> doc (** Parse the contents of a doc.text annotation. *) val get_doc : Ast.loc -> Ast.annot -> doc option (** Get and parse doc data from annotations. *) val html_of_doc : doc -> string (** Convert parsed doc into HTML. *) atd-2.1.0/atd/src/doc_lexer.mll000066400000000000000000000064131357165332000163040ustar00rootroot00000000000000(* $Id: ag_doc_lexer.mll 48186 2010-09-09 22:24:27Z martin $ *) { open Doc_types let close_paragraph a1 a2 a3 = let a2 = match String.concat "" (List.rev a3) with "" -> a2 | s -> Text s :: a2 in match List.rev a2 with [] -> a1 | l -> Paragraph l :: a1 } let space = [' ' '\t' '\r' '\n'] let space' = space#['\n'] let par_special = ['\\' '{' '}'] let par_not_special = [^ '\\' '{' '}' ' ' '\t' '\r' '\n'] let verb_not_special = [^ '\\' ' ' '\t' '\r' '\n' '}'] (* Paragraph mode *) rule paragraph a1 a2 a3 = parse '\\' ('\\' | "{{" | "{{{" as s) { paragraph a1 a2 (s :: a3) lexbuf } | "{{" { let code = inline_verbatim [] lexbuf in let a2 = match String.concat "" (List.rev a3) with "" -> a2 | s -> Text s :: a2 in let a2 = Code code :: a2 in paragraph a1 a2 [] lexbuf } | space* "{{{" (("\r"?) "\n")? { let pre = verbatim [] lexbuf in let a1 = close_paragraph a1 a2 a3 in let a1 = Pre pre :: a1 in paragraph a1 [] [] lexbuf } | par_not_special+ as s { paragraph a1 a2 (s :: a3) lexbuf } | space'* "\n"? space'* { paragraph a1 a2 (" " :: a3) lexbuf } | space'* "\n" (space'* "\n")+ space'* { let a1 = close_paragraph a1 a2 a3 in paragraph a1 [] [] lexbuf } | space* eof { let a1 = close_paragraph a1 a2 a3 in List.rev a1 } | _ as c { paragraph a1 a2 (String.make 1 c :: a3) lexbuf } (* Inline verbatim mode: Only "}}" need to be escaped. Backslashes can be escaped but single backslashes are tolerated. *) and inline_verbatim accu = parse "\\\\" { inline_verbatim ("\\" :: accu) lexbuf } | "\\}}" { inline_verbatim ("}}" :: accu) lexbuf } | space+ { inline_verbatim (" " :: accu) lexbuf } | verb_not_special+ as s { inline_verbatim (s :: accu) lexbuf } | _ as c { inline_verbatim (String.make 1 c :: accu) lexbuf } | space* "}}" { String.concat "" (List.rev accu) } | eof { failwith "Missing `}}'" } (* Verbatim paragraph mode: Only "}}}" need to be escaped. Backslashes can be escaped but single backslashes are tolerated. *) and verbatim accu = parse "\\\\" { verbatim ("\\" :: accu) lexbuf } | "\\}}}" { verbatim ("}}}" :: accu) lexbuf } | '\t' { verbatim (" " :: accu) lexbuf } | "\r\n" { verbatim ("\n" :: accu) lexbuf } | verb_not_special+ as s { verbatim (s :: accu) lexbuf } | _ as c { verbatim (String.make 1 c :: accu) lexbuf } | ('\r'? '\n')? "}}}" { String.concat "" (List.rev accu) } | eof { failwith "Missing `}}}'" } { let parse_string s = let lexbuf = Lexing.from_string s in paragraph [] [] [] lexbuf } atd-2.1.0/atd/src/doc_types.ml000066400000000000000000000001611357165332000161470ustar00rootroot00000000000000type inline = | Text of string | Code of string type block = | Paragraph of inline list | Pre of string atd-2.1.0/atd/src/dune000066400000000000000000000002001357165332000144740ustar00rootroot00000000000000(ocamllex lexer doc_lexer) (menhir (modules parser)) (library (name atd) (public_name atd) (libraries easy-format unix re)) atd-2.1.0/atd/src/expand.ml000066400000000000000000000422451357165332000154460ustar00rootroot00000000000000(* Monomorphization of type expressions. The goal is to inline each parametrized type definition as much as possible, allowing code generators to create more efficient code directly: type ('a, 'b) t = [ Foo of 'a | Bar of 'b ] type int_t = (int, int) t becomes: type int_t = _1 type _1 = [ Foo of int | Bar of int ] A secondary goal is to factor out type subexpressions in order for the code generators to produce less code: type x = { x : int list } type y = { y : int list option } becomes: type x = { x : _1 } type y = { y : _2 } type _1 = int list (* `int list' now occurs only once *) type _2 = _1 option By default, only parameterless type definitions are returned. The [keep_poly] option allows to return parametrized type definitions as well. Input: type 'a abs = abstract type int_abs = int abs type 'a tree = [ Leaf of 'a | Node of ('a tree * 'a tree) ] type t = int tree type x = [ Foo | Bar ] tree Output (pseudo-syntax where quoted strings indicate unique type identifiers): type "int abs" = int abs type int_abs = "int abs" type 'a tree = [ Leaf of 'a | Node of ('a tree * 'a tree) ] (* only if keep_poly = true *) type "int tree" = [ Leaf of int | Node of ("int tree" * "int tree") ] type t = "int tree" type "[ Foo | Bar ] tree" = [ Leaf of [ Foo | Bar ] | Node of ("[ Foo | Bar ] tree" * "[ Foo | Bar ] tree") ] type x = "[ Foo | Bar ] tree" *) open Import open Ast module S = Set.Make (String) module M = Map.Make (String) (* To support -o-name-overlap, we need to generate a few type annotations. But types generated by expansion like _1, _2, etc. are not actually written out in the interface or implementation, so they must be mapped back to the original polymorphic types for annotation purposes. This table contains the mappings. Its format is: key = generated type name value = (original type name, original number of parameters) For example, if we have the generated output: type 'a t = ... type _1 = int t Then the idea is, in the reader and writer functions, instead of using _1 in the annotation, we use _ t. The entry in original_types would be: ("_1", ("t", 1)) (The alternate strategy of actually producing a definition for type _1 aliasing int t in the implementation doesn't work, because the annotations will disagree with the interface in the case of recursive types.) *) type original_types = (string, string * int) Hashtbl.t (* Format of the table: key = type name (without arguments) value = (order in the file, number of parameters, original annotations of the right-hand type expression, original type definition, rewritten type definition) Every entry has an original type definition except the predefined atoms (int, string, etc.) and newly-created type definitions (type _1 = ...). *) let init_table () = let seqnum = ref 0 in let tbl = Hashtbl.create 20 in List.iter ( fun (k, n, opt_td) -> incr seqnum; Hashtbl.add tbl k (!seqnum, n, opt_td, None) ) Predef.list; seqnum, tbl let rec mapvar_expr (f : string -> string) (x : Ast.type_expr) : Ast.type_expr = match x with Sum (loc, vl, a) -> Sum (loc, List.map (mapvar_variant f) vl, a) | Record (loc, fl, a) -> Record (loc, List.map (mapvar_field f) fl, a) | Tuple (loc, tl, a) -> Tuple (loc, List.map (fun (loc, x, a) -> (loc, mapvar_expr f x, a)) tl, a) | List (loc, t, a) -> List (loc, mapvar_expr f t, a) | Name (loc, (loc2, "list", [t]), a) -> Name (loc, (loc2, "list", [mapvar_expr f t]), a) | Option (loc, t, a) -> Option (loc, mapvar_expr f t, a) | Name (loc, (loc2, "option", [t]), a) -> Name (loc, (loc2, "option", [mapvar_expr f t]), a) | Nullable (loc, t, a) -> Nullable (loc, mapvar_expr f t, a) | Name (loc, (loc2, "nullable", [t]), a) -> Name (loc, (loc2, "nullable", [mapvar_expr f t]), a) | Shared (loc, t, a) -> Shared (loc, mapvar_expr f t, a) | Name (loc, (loc2, "shared", [t]), a) -> Name (loc, (loc2, "shared", [mapvar_expr f t]), a) | Wrap (loc, t, a) -> Wrap (loc, mapvar_expr f t, a) | Name (loc, (loc2, "wrap", [t]), a) -> Name (loc, (loc2, "wrap", [mapvar_expr f t]), a) | Tvar (loc, s) -> Tvar (loc, f s) | Name (loc, (loc2, k, args), a) -> Name (loc, (loc2, k, List.map (mapvar_expr f) args), a) and mapvar_field f = function `Field (loc, k, t) -> `Field (loc, k, mapvar_expr f t) | `Inherit (loc, t) -> `Inherit (loc, mapvar_expr f t) and mapvar_variant f = function | Variant (loc, k, opt_t) -> Variant (loc, k, (Option.map (mapvar_expr f) opt_t)) | Inherit (loc, t) -> Inherit (loc, mapvar_expr f t) let var_of_int i = let letter = i mod 26 in let number = i / 26 in let prefix = String.make 1 (Char.chr (letter + Char.code 'a')) in if number = 0 then prefix else prefix ^ string_of_int number let vars_of_int n = List.init n var_of_int let is_special s = String.length s > 0 && s.[0] = '@' (* Standardize a type expression by numbering the type variables using the order in which they are encountered. input: (int, 'b, 'z) foo output: - new_name: "@(int, 'a, 'b) foo" - new_args: [ 'b; 'z ] - new_env: [ ('b, 'a); ('z, 'b) ] new_name and new_args constitute the type expression that replaces the original one: (int, 'b, 'z) foo --> ('b, 'z) "@(int, 'a, 'b) foo" new_env allows the substitution of the type variables of the original type expression into the type variables defined by the new type definition. *) let make_type_name loc orig_name args an = let tbl = Hashtbl.create 10 in let n = ref 0 in let mapping = ref [] in let assign_name s = try Hashtbl.find tbl s with Not_found -> let name = var_of_int !n in mapping := (s, name) :: !mapping; incr n; name in let normalized_args = List.map (mapvar_expr assign_name) args in let new_name = "@(" ^ Print.string_of_type_name orig_name normalized_args an ^ ")" in let mapping = List.rev !mapping in let new_args = List.map (fun (old_s, _) -> Tvar (loc, old_s)) mapping in let new_env = List.map (fun (old_s, new_s) -> old_s, Tvar (loc, new_s)) mapping in new_name, new_args, new_env let is_abstract (x : type_expr) = match x with Name (_, (_, "abstract", _), _) -> true | _ -> false let expr_of_lvalue loc name param annot = Name (loc, (loc, name, List.map (fun s -> Tvar (loc, s)) param), annot) let is_cyclic lname t = match t with Name (_, (_, rname, _), _) -> lname = rname | _ -> false let is_tvar = function Tvar _ -> true | _ -> false let add_annot (x : type_expr) a : type_expr = Ast.map_annot (fun a0 -> Annot.merge (a @ a0)) x let expand ?(keep_poly = false) (l : type_def list) : type_def list * original_types = let seqnum, tbl = init_table () in let original_types = Hashtbl.create 16 in let rec subst env (t : type_expr) : type_expr = match t with Sum (loc, vl, a) -> Sum (loc, List.map (subst_variant env) vl, a) | Record (loc, fl, a) -> Record (loc, List.map (subst_field env) fl, a) | Tuple (loc, tl, a) -> Tuple (loc, List.map (fun (loc, x, a) -> (loc, subst env x, a)) tl, a) | List (loc as loc2, t, a) | Name (loc, (loc2, "list", [t]), a) -> let t' = subst env t in subst_type_name loc loc2 "list" [t'] a | Option (loc as loc2, t, a) | Name (loc, (loc2, "option", [t]), a) -> let t' = subst env t in subst_type_name loc loc2 "option" [t'] a | Nullable (loc as loc2, t, a) | Name (loc, (loc2, "nullable", [t]), a) -> let t' = subst env t in subst_type_name loc loc2 "nullable" [t'] a | Shared (loc as loc2, t, a) | Name (loc, (loc2, "shared", [t]), a) -> let t' = subst env t in subst_type_name loc loc2 "shared" [t'] a | Wrap (loc as loc2, t, a) | Name (loc, (loc2, "wrap", [t]), a) -> let t' = subst env t in subst_type_name loc loc2 "wrap" [t'] a | Tvar (_, s) as x -> Option.value (List.assoc s env) ~default:x | Name (loc, (loc2, name, args), a) -> let args' = List.map (subst env) args in if List.for_all is_tvar args' then Name (loc, (loc2, name, args'), a) else subst_type_name loc loc2 name args' a and subst_type_name loc loc2 name args an = (* Reduce the number of arguments of the type by creating an intermediate type, e.g.: ('x, int) t becomes 'x "('a, int) t" and the following type is created: type 'a "('a, int) t" = ... input: - type name with arguments expressed in the environment where the type expression was extracted - annotations for that type expression output: - equivalent type expression valid in the same environment side-effects: - creation of a type definition for the output type expression. *) let new_name, new_args, new_env = make_type_name loc2 name args an in let n_param = List.length new_env in if not (Hashtbl.mem tbl new_name) then create_type_def loc name args new_env new_name n_param an; (* Return new type name with new arguments. The annotation has been transferred to the right-hand expression of the new type definition. *) Name (loc, (loc2, new_name, new_args), []) and create_type_def loc orig_name orig_args env name n_param an0 = (* Create the type definition needed to support the new type name [name] expecting [n_param] parameters. The right-hand side of the definition is obtained by looking up the definition for type [orig_name]: type ('a, 'b) t = [ Foo of 'a | Bar of 'b ] type 'c it = (int, 'c) t output: type ('a, 'b) t = [ Foo of 'a | Bar of 'b ] type 'a _1 = [ Foo of int | Bar of 'a ] (* new name = _1, n_param = 1 *) type 'c it = 'c _1 *) incr seqnum; let i = !seqnum in (* Create entry in the table, indicating that we are working on it *) Hashtbl.add tbl name (i, n_param, None, None); Hashtbl.add original_types name (orig_name, List.length orig_args); (* Get the original type definition *) let (_, _, orig_opt_td, _) = try Hashtbl.find tbl orig_name with Not_found -> assert false (* All original type definitions must have been put in the table initially *) in let ((_, _, _) as td') = match orig_opt_td with None -> assert false (* Original type definitions must all exist, even for predefined types and abstract types. *) | Some (_, (k, pl, def_an), t) -> assert (k = orig_name); let new_params = vars_of_int n_param in let t = add_annot t an0 in let t = set_type_expr_loc loc t in (* First replace the type expression being specialized (orig_name, orig_args) by the equivalent expression in the new environment (variables 'a, 'b, ...) (int, 'b) foo --> (int, 'a) foo *) let args = List.map (subst env) orig_args in (* Then expand the expression into its definition, replacing each variable by the actual argument: original definition: type ('x, 'y) foo = [ Foo of 'x | Bar of 'y ] new definition: type 'a _1 = ... right-hand expression becomes: [ Foo of int | Bar of 'a ] using the following environment: 'x -> int 'y -> 'a *) let env = List.map2 (fun var value -> (var, value)) pl args in let t' = if is_abstract t then (* e.g.: type 'a t = abstract use 'a t and preserve "t" *) let t = expr_of_lvalue loc orig_name pl (Ast.annot_of_type_expr t) in subst_only_args env t else let t' = subst env t in if is_cyclic name t' then subst_only_args env t else t' in (loc, (name, new_params, def_an), t') in Hashtbl.replace tbl name (i, n_param, None, Some td') and subst_field env = function `Field (loc, k, t) -> `Field (loc, k, subst env t) | `Inherit (loc, t) -> `Inherit (loc, subst env t) and subst_variant env = function Variant (loc, k, opt_t) as x -> (match opt_t with None -> x | Some t -> Variant (loc, k, Some (subst env t)) ) | Inherit (loc, t) -> Inherit (loc, subst env t) and subst_only_args env = function List (loc, t, a) | Name (loc, (_, "list", [t]), a) -> List (loc, subst env t, a) | Option (loc, t, a) | Name (loc, (_, "option", [t]), a) -> Option (loc, subst env t, a) | Nullable (loc, t, a) | Name (loc, (_, "nullable", [t]), a) -> Nullable (loc, subst env t, a) | Shared (loc, t, a) | Name (loc, (_, "shared", [t]), a) -> Shared (loc, subst env t, a) | Wrap (loc, t, a) | Name (loc, (_, "wrap", [t]), a) -> Wrap (loc, subst env t, a) | Name (loc, (loc2, name, args), an) -> Name (loc, (loc2, name, List.map (subst env) args), an) | _ -> assert false in (* first pass: add all original definitions to the table *) List.iter ( fun ((_, (k, pl, _), _) as td) -> incr seqnum; let i = !seqnum in let n = List.length pl in Hashtbl.add tbl k (i, n, Some td, None) ) l; (* second pass: perform substitutions and insert new definitions *) List.iter ( fun ((loc, (k, pl, a), t) as td) -> if pl = [] || keep_poly then ( let (i, n, _, _) = try Hashtbl.find tbl k with Not_found -> assert false in let t' = subst [] t in let td' = (loc, (k, pl, a), t') in Hashtbl.replace tbl k (i, n, Some td, Some td') ) ) l; (* third pass: collect all parameterless definitions *) let l = Hashtbl.fold ( fun _ (i, n, _, opt_td') l -> match opt_td' with None -> l | Some td' -> if n = 0 || keep_poly then (i, td') :: l else l ) tbl [] in let l = List.sort (fun (i, _) (j, _) -> compare i j) l in (List.map snd l, original_types) let replace_type_names (subst : string -> string) (t : type_expr) : type_expr = let rec replace (t : type_expr) : type_expr = match t with Sum (loc, vl, a) -> Sum (loc, List.map replace_variant vl, a) | Record (loc, fl, a) -> Record (loc, List.map replace_field fl, a) | Tuple (loc, tl, a) -> Tuple (loc, List.map (fun (loc, x, a) -> loc, replace x, a) tl, a) | List (loc, t, a) -> List (loc, replace t, a) | Option (loc, t, a) -> Option (loc, replace t, a) | Nullable (loc, t, a) -> Nullable (loc, replace t, a) | Shared (loc, t, a) -> Shared (loc, replace t, a) | Wrap (loc, t, a) -> Wrap (loc, replace t, a) | Tvar (_, _) as t -> t | Name (loc, (loc2, k, l), a) -> Name (loc, (loc2, subst k, List.map replace l), a) and replace_field = function `Field (loc, k, t) -> `Field (loc, k, replace t) | `Inherit (loc, t) -> `Inherit (loc, replace t) and replace_variant = function Variant (loc, k, opt_t) as x -> (match opt_t with None -> x | Some t -> Variant (loc, k, Some (replace t)) ) | Inherit (loc, t) -> Inherit (loc, replace t) in replace t let standardize_type_names ~prefix ~original_types (l : type_def list) : type_def list = let new_id = let n = ref 0 in let rec f tbl = incr n; let id = prefix ^ string_of_int !n in if Hashtbl.mem tbl id then f tbl else id in f in let tbl = Hashtbl.create 50 in List.iter (fun (k, _, _) -> Hashtbl.add tbl k k) Predef.list; List.iter ( fun (_, (k, _, _), _) -> if not (is_special k) then ( Hashtbl.add tbl k k ) ) l; let replace_name k = try Hashtbl.find tbl k with Not_found -> assert (is_special k); let k' = new_id tbl in Hashtbl.add tbl k k'; begin try let orig_info = Hashtbl.find original_types k in Hashtbl.remove original_types k; Hashtbl.add original_types k' orig_info with Not_found -> assert false (* Must have been added during expand *) end; k' in let l = List.map ( fun (loc, (k, pl, a), t) -> let k' = replace_name k in (loc, (k', pl, a), t) ) l in let subst s = try Hashtbl.find tbl s with Not_found -> (* must have been defined as abstract *) s in List.map (fun (loc, x, t) -> (loc, x, replace_type_names subst t)) l let expand_module_body ?(prefix = "_") ?keep_poly ?(debug = false) l = let td_list = List.map (function (Type td) -> td) l in let (td_list, original_types) = expand ?keep_poly td_list in let td_list = if debug then td_list else standardize_type_names ~prefix ~original_types td_list in (List.map (fun td -> (Type td)) td_list, original_types) atd-2.1.0/atd/src/expand.mli000066400000000000000000000046341357165332000156170ustar00rootroot00000000000000(** Monomorphization of type definitions *) type original_types = (string, string * int) Hashtbl.t (** To support the generation of annotations for types that are created during the monomorphization process, a mapping must be kept connecting the monomorphic type name to the original polymorphic one, including its original number of parameters. This table is only used in producing those annotations to support the Atdgen command line option -o-name-overlap. It can probably be ignored for most uses of expand_module_body. *) val expand_module_body : ?prefix:string -> ?keep_poly:bool -> ?debug:bool -> Ast.module_body -> Ast.module_body * original_types (** Monomorphization of type expressions. @param prefix prefix to use for new type names. Default is ["_"]. @param keep_poly return definitions for the parametrized types. Default is [false]. @param debug keep meaningful but non ATD-compliant names for new type names. Default is [false]. The goal is to inline each parametrized type definition as much as possible, allowing code generators to create more efficient code directly: {v type ('a, 'b) t = [ Foo of 'a | Bar of 'b ] type int_t = (int, int) t v} becomes: {v type int_t = _1 type _1 = [ Foo of int | Bar of int ] v} A secondary goal is to factor out type subexpressions in order for the code generators to produce less code: {v type x = \{ x : int list } type y = \{ y : int list option } v} becomes: {v type x = \{ x : _1 } type y = \{ y : _2 } type _1 = int list (* `int list' now occurs only once *) type _2 = _1 option v} By default, only parameterless type definitions are returned. The [keep_poly] option allows to return parametrized type definitions as well. Input: {v type 'a abs = abstract type int_abs = int abs type 'a tree = [ Leaf of 'a | Node of ('a tree * 'a tree) ] type t = int tree type x = [ Foo | Bar ] tree v} Output (pseudo-syntax where quoted strings indicate unique type identifiers): {v type "int abs" = int abs type int_abs = "int abs" type 'a tree = [ Leaf of 'a | Node of ('a tree * 'a tree) ] (* only if keep_poly = true *) type "int tree" = [ Leaf of int | Node of ("int tree" * "int tree") ] type t = "int tree" type "[ Foo | Bar ] tree" = [ Leaf of [ Foo | Bar ] | Node of ("[ Foo | Bar ] tree" * "[ Foo | Bar ] tree") ] type x = "[ Foo | Bar ] tree" v} *) atd-2.1.0/atd/src/import.ml000066400000000000000000000043101357165332000154700ustar00rootroot00000000000000module String = struct [@@@ocaml.warning "-3-32"] let lowercase_ascii = StringLabels.lowercase let uppercase_ascii = StringLabels.uppercase let capitalize_ascii = StringLabels.capitalize include String end module Char = struct [@@@ocaml.warning "-3-32"] let uppercase_ascii = Char.uppercase include Char end module List = struct include List let rec filter_map f = function [] -> [] | x :: l -> match f x with None -> filter_map f l | Some y -> y :: filter_map f l let concat_map f l = List.map f l |> List.flatten let map_first f = function | [] -> [] | x :: l -> let y = f ~is_first:true x in y :: List.map (f ~is_first:false) l let init n f = Array.to_list (Array.init n f) let mapi l f = Array.of_list l |> Array.mapi f |> Array.to_list let rec find_map f = function | [] -> None | x :: l -> match f x with None -> find_map f l | Some _ as y -> y (* replace first occurrence, if any *) let rec assoc_update k v = function | (k', _) as x :: l -> if k = k' then (k, v) :: l else x :: assoc_update k v l | [] -> [] let rec insert_sep t ~sep = match t with | [] | [_] -> t | x :: xs -> x :: sep @ (insert_sep xs ~sep) let split3 l = let (x, y, z) = List.fold_left (fun (xs, ys, zs) (x, y, z) -> (x::xs, y::ys, z::zs) ) ([], [], []) l in (List.rev x, List.rev y, List.rev z) let assoc_exn = assoc let assoc key xs = match List.assoc key xs with | s -> Some s | exception Not_found -> None end module Option = struct let map f = function | None -> None | Some s -> Some (f s) let value_exn = function | None -> failwith "Option.value_exn" | Some s -> s let value ~default = function | None -> default | Some s -> s let is_some = function | None -> false | Some _ -> true module O = struct let (>>=) x f = match x with | None -> None | Some x -> f x end end let sprintf = Printf.sprintf let printf = Printf.printf let eprintf = Printf.eprintf let bprintf = Printf.bprintf let fprintf = Printf.fprintf atd-2.1.0/atd/src/inherit.ml000066400000000000000000000074701357165332000156320ustar00rootroot00000000000000(* Perform inheritance. *) open Import open Ast module S = Set.Make (String) let load_defs l = let tbl = Predef.make_table () in List.iter ( fun ((_, (k, pl, _), _) as td) -> Hashtbl.add tbl k (List.length pl, Some td) ) l; tbl let keep_last_defined get_name l = let _, l = List.fold_right ( fun x (set, l) -> let k = get_name x in if S.mem k set then (set, l) else (S.add k set, x :: l) ) l (S.empty, []) in l let get_field_name : field -> string = function `Field (_, (k, _, _), _) -> k | `Inherit _ -> assert false let get_variant_name : variant -> string = function Variant (_, (k, _), _) -> k | Inherit _ -> assert false let expand ?(inherit_fields = true) ?(inherit_variants = true) tbl t0 = let rec subst deref param (t : type_expr) : type_expr = match t with Sum (loc, vl, a) -> let vl = List.concat_map (subst_variant param) vl in let vl = if inherit_variants then keep_last_defined get_variant_name vl else vl in Sum (loc, vl, a) | Record (loc, fl, a) -> let fl = List.concat_map (subst_field param) fl in let fl = if inherit_fields then keep_last_defined get_field_name fl else fl in Record (loc, fl, a) | Tuple (loc, tl, a) -> Tuple ( loc, List.map (fun (loc, x, a) -> (loc, subst false param x, a)) tl, a ) | List (loc, t, a) | Name (loc, (_, "list", [t]), a) -> List (loc, subst false param t, a) | Option (loc, t, a) | Name (loc, (_, "option", [t]), a) -> Option (loc, subst false param t, a) | Nullable (loc, t, a) | Name (loc, (_, "nullable", [t]), a) -> Nullable (loc, subst false param t, a) | Shared (loc, t, a) | Name (loc, (_, "shared", [t]), a) -> Shared (loc, subst false param t, a) | Wrap (loc, t, a) | Name (loc, (_, "wrap", [t]), a) -> Wrap (loc, subst false param t, a) | Tvar (_, s) -> Option.value (List.assoc s param) ~default:t | Name (loc, (loc2, k, args), a) -> let expanded_args = List.map (subst false param) args in if deref then let _, vars, _, t = try match Hashtbl.find tbl k with _, Some (_, (k, vars, a), t) -> k, vars, a, t | _, None -> failwith ("Cannot inherit from type " ^ k) with Not_found -> failwith ("Missing type definition for " ^ k) in let param = List.combine vars expanded_args in subst true param t else Name (loc, (loc2, k, expanded_args), a) and subst_field param = function `Field (loc, k, t) -> [ `Field (loc, k, subst false param t) ] | `Inherit (_, t) as x -> (match subst true param t with Record (_, vl, _) -> if inherit_fields then vl else [ x ] | _ -> failwith "Not a record type" ) and subst_variant param = function Variant (loc, k, opt_t) as x -> (match opt_t with None -> [ x ] | Some t -> [ Variant (loc, k, Some (subst false param t)) ] ) | Inherit (_, t) as x -> (match subst true param t with Sum (_, vl, _) -> if inherit_variants then vl else [ x ] | _ -> failwith "Not a sum type" ) in subst false [] t0 let expand_module_body ?inherit_fields ?inherit_variants (l : Ast.module_body) = let td_list = List.map (function (Ast.Type td) -> td) l in let tbl = load_defs td_list in let td_list = List.map ( fun (loc, name, t) -> (loc, name, expand ?inherit_fields ?inherit_variants tbl t) ) td_list in List.map (fun td -> Ast.Type td) td_list atd-2.1.0/atd/src/inherit.mli000066400000000000000000000006721357165332000160000ustar00rootroot00000000000000(** Expansion of [inherit] statements *) val expand_module_body : ?inherit_fields : bool -> ?inherit_variants : bool -> Ast.module_body -> Ast.module_body (** Expand [inherit] statements found in sum types and product types. @param inherit_fields specify whether record fields should be expanded. Default is true. @param inherit_variants specify whether sum types should be expanded. Default is true. *) atd-2.1.0/atd/src/lexer.mll000066400000000000000000000120331357165332000154520ustar00rootroot00000000000000 { open Import open Lexing open Parser let lexing_error lexbuf msg = let loc = (lexeme_start_p lexbuf, lexeme_end_p lexbuf) in Ast.error (Ast.string_of_loc loc ^ "\n" ^ msg) type accu = { mutable depth : int; buf : Buffer.t } let newline lexbuf = let pos = lexbuf.lex_curr_p in lexbuf.lex_curr_p <- { pos with pos_lnum = pos.pos_lnum + 1; pos_bol = pos.pos_cnum } let int_of_dec c = match c with '0'..'9' -> Char.code c - 48 | _ -> invalid_arg "int_of_dec" let int_of_hex c = match c with '0'..'9' -> Char.code c - 48 | 'a'..'f' -> Char.code c - 87 | 'A'..'F' -> Char.code c - 55 | _ -> invalid_arg "int_of_hex" let byte_of_hex a b = Char.chr (int_of_hex a lsl 4 + int_of_hex b) let byte_of_dec a b c = let x = int_of_dec a * 100 + int_of_dec b * 10 + int_of_dec c in if x > 255 then invalid_arg "byte_of_dec" else Char.chr x let utf8_of_hex4 buf b1 b2 b3 b4 = (* covers only U+0000-U+FFFF *) let a = int_of_hex b1 lsl 4 + int_of_hex b2 in let b = int_of_hex b3 lsl 4 + int_of_hex b4 in let u = a lsl 8 + b in let add buf i = Buffer.add_char buf (Char.chr (i land 0xff)) in if u <= 0x007f then add buf u else if u <= 0x07ff then ( add buf (0b11000000 lor (a lsl 2) lor (b lsr 6)); add buf (0b10000000 lor (b land 0b00111111)) ) else if u <= 0xffff then ( add buf (0b11100000 lor (a lsr 4)); add buf (0b10000000 lor ((a lsl 2) land 0b00111100) lor (b lsr 6)); add buf (0b10000000 lor (b land 0b00111111)) ) else invalid_arg "utf8_of_hex4" (* let test_utf8_of_hex s = assert (String.length s = 4); let buf = Buffer.create 10 in utf8_of_hex4 buf s.[0] s.[1] s.[2] s.[3]; let file = Filename.temp_file "debug" "" in let oc = open_out file in output_string oc (Buffer.contents buf); close_out oc; assert (Sys.command ("xxd -b " ^ file) = 0); Sys.remove file *) ;; } let upper = ['A'-'Z'] let lower = ['a'-'z'] let digit = ['0'-'9'] let identchar = upper | lower | digit | ['_' '\''] let hex = ['0'-'9' 'a'-'f' 'A'-'F'] let lident = (lower | '_' identchar) identchar* let uident = upper identchar* let blank = [ ' ' '\t' ] let newline = '\r'? '\n' let space = [ ' ' '\t' '\r' '\n' ] rule token = parse | "(" { OP_PAREN } | ")" { CL_PAREN } | "[" { OP_BRACK } | "]" { CL_BRACK } | "{" { OP_CURL } | "}" { CL_CURL } | "<" { LT } | ">" { GT } | ";" { SEMICOLON } | "," { COMMA } | ":" { COLON } | "*" { STAR } | "|" { BAR } | "=" { EQ } | "?" { QUESTION } | "~" { TILDE } | "." { DOT } | "type" { TYPE } | "of" { OF } | "inherit" { INHERIT } | lident as s { LIDENT s } | uident as s { UIDENT s } | "'" (lident as s) { TIDENT s } | newline { newline lexbuf; token lexbuf } | blank+ { token lexbuf } | eof { EOF } | '"' { STRING (string (Buffer.create 200) lexbuf) } | "(*" { comment 1 lexbuf; token lexbuf } | _ as c { lexing_error lexbuf (sprintf "Illegal character %S" (String.make 1 c)) } and string buf = parse | '"' { Buffer.contents buf } | '\\' (['\\' '"'] as c) { Buffer.add_char buf c; string buf lexbuf } | "\\x" (hex as a) (hex as b) { Buffer.add_char buf (byte_of_hex a b); string buf lexbuf } | '\\' (digit as a) (digit as b) (digit as c) { Buffer.add_char buf (byte_of_dec a b c); string buf lexbuf } | "\\n" { Buffer.add_char buf '\n'; string buf lexbuf } | "\\r" { Buffer.add_char buf '\r'; string buf lexbuf } | "\\t" { Buffer.add_char buf '\t'; string buf lexbuf } | "\\b" { Buffer.add_char buf '\b'; string buf lexbuf } | '\n' { newline lexbuf; Buffer.add_char buf '\n'; string buf lexbuf } | '\\' newline blank* { newline lexbuf; string buf lexbuf } | '\\' { lexing_error lexbuf "Invalid escape sequence" } | _ as c { Buffer.add_char buf c; string buf lexbuf } | eof { lexing_error lexbuf "Unterminated string" } and comment depth = parse | "*)" { if depth > 1 then comment (depth - 1) lexbuf } | "(*" { comment (depth + 1) lexbuf } | '"' { ignore (string (Buffer.create 200) lexbuf); comment depth lexbuf } | newline { newline lexbuf; comment depth lexbuf } | _ { comment depth lexbuf } | eof { lexing_error lexbuf "Unterminated comment" } { let init_fname lexbuf fname lnum = lexbuf.lex_start_p <- { lexbuf.lex_start_p with pos_fname = fname; pos_lnum = lnum }; lexbuf.lex_curr_p <- { lexbuf.lex_curr_p with pos_fname = fname; pos_lnum = lnum } } atd-2.1.0/atd/src/parser.mly000066400000000000000000000143151357165332000156510ustar00rootroot00000000000000/* ATD Parser requires menhir. */ %{ open Import open Ast let syntax_error s pos1 pos2 = let msg = sprintf "%s:\n%s" (string_of_loc (pos1, pos2)) s in error msg %} %token TYPE EQ OP_PAREN CL_PAREN OP_BRACK CL_BRACK OP_CURL CL_CURL SEMICOLON COMMA COLON STAR OF EOF BAR LT GT INHERIT QUESTION TILDE DOT %token < string > STRING LIDENT UIDENT TIDENT %start full_module %type < Ast.full_module > full_module %% full_module: | x = annot y = module_body { ((($startpos(x), $endpos(x)), x), y) } ; module_body: | module_item module_body { $1 :: $2 } | EOF { [] } | _e=error { syntax_error "Syntax error" $startpos(_e) $endpos(_e) } ; annot: | x = asection l = annot { x :: l } | { ([] : annot) } ; asection: | LT x = LIDENT l = afield_list GT { (x, (($startpos, $endpos), l)) } | LT LIDENT afield_list _e=error { syntax_error "Expecting '>'" $startpos(_e) $endpos(_e) } | LT _e=error { syntax_error "Expecting lowercase identifier" $startpos(_e) $endpos(_e) } ; afield_list: | x = afield l = afield_list { x :: l } | { [] } ; afield: | lident_path EQ STRING { (String.concat "." $1, (($startpos, $endpos), Some $3)) } | lident_path { (String.concat "." $1, (($startpos, $endpos), None)) } ; lident_path: | LIDENT DOT lident_path { $1 :: $3 } | LIDENT { [$1] } ; module_item: | TYPE p = type_param s = LIDENT a = annot EQ t = type_expr { Type (($startpos, $endpos), (s, p, a), t) } | TYPE type_param LIDENT annot EQ _e=error { syntax_error "Expecting type expression" $startpos(_e) $endpos(_e) } | TYPE type_param LIDENT annot _e=error { syntax_error "Expecting '='" $startpos(_e) $endpos(_e) } | TYPE _e=error { syntax_error "Expecting type name" $startpos(_e) $endpos(_e) } ; type_param: | TIDENT { [ $1 ] } | OP_PAREN type_var_list CL_PAREN { $2 } | { [] } | OP_PAREN type_var_list _e=error { syntax_error "Expecting ')'" $startpos(_e) $endpos(_e) } ; type_var_list: | TIDENT COMMA type_var_list { $1 :: $3 } | TIDENT { [ $1 ] } ; type_expr: | OP_BRACK l = variant_list CL_BRACK a = annot { Sum (($startpos, $endpos), l, a) } | OP_BRACK CL_BRACK a = annot { Sum (($startpos, $endpos), [], a) } | OP_CURL l = field_list CL_CURL a = annot { Record (($startpos, $endpos), l, a) } | OP_CURL CL_CURL a = annot { Record (($startpos, $endpos), [], a) } | OP_PAREN x = annot_expr CL_PAREN a = annot { Tuple (($startpos, $endpos), [x], a) } | OP_PAREN l = cartesian_product CL_PAREN a = annot { Tuple (($startpos, $endpos), l, a) } | x = type_inst a = annot { let pos1 = $startpos in let pos2 = $endpos in let loc = (pos1, pos2) in let _, name, args = x in match name, args with "list", [x] -> List (loc, x, a) | "option", [x] -> Option (loc, x, a) | "nullable", [x] -> Nullable (loc, x, a) | "shared", [x] -> let a = if Annot.has_field ~sections:["share"] ~field:"id" a then (* may cause ID clashes if not used properly *) a else Annot.set_field ~loc ~section:"share" ~field:"id" (Some (Annot.create_id ())) a in Shared (loc, x, a) | "wrap", [x] -> Wrap (loc, x, a) | ("list"|"option"|"nullable"|"shared"|"wrap"), _ -> syntax_error (sprintf "%s expects one argument" name) pos1 pos2 | _ -> (Name (loc, x, a) : type_expr) } | x = TIDENT { Tvar (($startpos, $endpos), x) } | OP_BRACK variant_list _e=error { syntax_error "Expecting ']'" $startpos(_e) $endpos(_e) } | OP_CURL field_list _e=error { syntax_error "Expecting '}'" $startpos(_e) $endpos(_e) } | OP_PAREN cartesian_product _e=error { syntax_error "Expecting ')'" $startpos(_e) $endpos(_e) } ; cartesian_product: | x = annot_expr STAR l = cartesian_product { x :: l } | x = annot_expr STAR y = annot_expr { [ x; y ] } | { [] } ; annot_expr: | a = annot COLON x = type_expr { (($startpos, $endpos), x, a) } | x = type_expr { (($startpos, $endpos), x, []) } ; type_inst: | l = type_args s = LIDENT { (($startpos, $endpos), s, l) } ; type_args: | type_expr { [ $1 ] } | OP_PAREN type_arg_list CL_PAREN { $2 } | { [] } | OP_PAREN type_arg_list _e=error { syntax_error "Expecting ')'" $startpos(_e) $endpos(_e) } ; type_arg_list: | type_expr COMMA type_arg_list { $1 :: $3 } | type_expr COMMA type_expr { [ $1; $3 ] } ; variant_list: | BAR variant_list0 { $2 } | variant_list0 { $1 } ; variant_list0: | variant BAR variant_list0 { $1 :: $3 } | variant { ([ $1 ] : variant list) } ; variant: | x = UIDENT a = annot OF t = type_expr { Variant (($startpos, $endpos), (x, a), Some t) } | x = UIDENT a = annot { Variant (($startpos, $endpos), (x, a), None) } | INHERIT t = type_expr { Inherit (($startpos, $endpos), t) } | UIDENT annot OF _e=error { syntax_error "Expecting type expression after 'of'" $startpos(_e) $endpos(_e) } ; field_list: | x = field SEMICOLON l = field_list { x :: l } | x = field SEMICOLON { [ x ] } | x = field { [ x ] } ; field: | fn = field_name a = annot COLON t = type_expr { let k, fk = fn in `Field (($startpos, $endpos), (k, fk, a), t) } | INHERIT t = type_expr { `Inherit (($startpos, $endpos), t) } | field_name annot COLON _e=error { syntax_error "Expecting type expression after ':'" $startpos(_e) $endpos(_e) } | field_name annot _e=error { syntax_error "Expecting ':'" $startpos(_e) $endpos(_e) } ; field_name: | k = LIDENT { (k, Required) } | QUESTION k = LIDENT { (k, Optional) } | TILDE k = LIDENT { (k, With_default) } ; atd-2.1.0/atd/src/predef.ml000066400000000000000000000022341357165332000154260ustar00rootroot00000000000000(* Table of predefined types. *) open Ast let list_def : type_def = let loc = dummy_loc in ( loc, ("list", ["a"], []), List (loc, Tvar (loc, "a"), []) ) let option_def : type_def = let loc = dummy_loc in ( loc, ("option", ["a"], []), Option (loc, Tvar (loc, "a"), []) ) let nullable_def : type_def = let loc = dummy_loc in ( loc, ("nullable", ["a"], []), Nullable (loc, Tvar (loc, "a"), []) ) let shared_def : type_def = let loc = dummy_loc in ( loc, ("shared", ["a"], []), Shared (loc, Tvar (loc, "a"), []) ) let wrap_def : type_def = let loc = dummy_loc in ( loc, ("wrap", ["a"], []), Wrap (loc, Tvar (loc, "a"), []) ) let list = [ "unit", 0, None; "bool", 0, None; "int", 0, None; "float", 0, None; "string", 0, None; "abstract", 0, None; "list", 1, Some list_def; "option", 1, Some option_def; "nullable", 1, Some nullable_def; "shared", 1, Some shared_def; "wrap", 1, Some wrap_def; ] let make_table () = let tbl = Hashtbl.create 20 in List.iter ( fun (k, n, opt_t) -> Hashtbl.add tbl k (n, opt_t) ) list; tbl atd-2.1.0/atd/src/predef.mli000066400000000000000000000002601357165332000155740ustar00rootroot00000000000000(** The collection of core types known by ATD. *) val list : (string * int * Ast.type_def option) list val make_table : unit -> (string, int * Ast.type_def option) Hashtbl.t atd-2.1.0/atd/src/print.ml000066400000000000000000000141461357165332000153220ustar00rootroot00000000000000open Easy_format open Ast let rlist = { list with wrap_body = `Force_breaks; indent_body = 0; align_closing = false; space_after_opening = false; space_before_closing = false } let plist = { list with align_closing = false; space_after_opening = false; space_before_closing = false } let hlist = { list with wrap_body = `No_breaks } let shlist = { hlist with stick_to_label = false; space_after_opening = false; space_before_closing = false } let shlist0 = { shlist with space_after_separator = false } let llist = { list with separators_stick_left = false; space_before_separator = true; space_after_separator = true } let lplist = { llist with space_after_opening = false; space_before_closing = false } let label0 = { label with space_after_label = false } let make_atom s = Atom (s, atom) let horizontal_sequence l = Easy_format.List (("", "", "", shlist), l) let horizontal_sequence0 l = Easy_format.List (("", "", "", shlist0), l) let quote_string s = Printf.sprintf "%S" s let format_prop (k, (_, opt)) = match opt with None -> make_atom k | Some s -> Label ( (make_atom (k ^ "="), label0), (make_atom (quote_string s)) ) let default_annot (s, (_, l)) = match l with [] -> make_atom ("<" ^ s ^ ">") | l -> List ( ("<", "", ">", plist), [ Label ( (make_atom s, label), List ( ("", "", "", plist), List.map format_prop l ) ) ] ) let string_of_field k = function Required -> k | Optional -> "?" ^ k | With_default -> "~" ^ k let make_closures format_annot = let append_annots (l : annot) x = match l with [] -> x | _ -> Label ( (x, label), List (("", "", "", plist), List.map format_annot l) ) in let prepend_colon_annots l x = match l with [] -> x | _ -> Label ( (Label ( (List (("", "", "", plist), List.map format_annot l), label0), make_atom ":" ), label), x ) in let rec format_module_item (x : module_item) = match x with Type (_, (s, param, a), t) -> let left = if a = [] then let l = make_atom "type" :: prepend_type_param param [ make_atom (s ^ " =") ] in horizontal_sequence l else let l = make_atom "type" :: prepend_type_param param [ make_atom s ] in let x = append_annots a (horizontal_sequence l) in horizontal_sequence [ x; make_atom "=" ] in Label ( (left, label), format_type_expr t ) and prepend_type_param l tl = match l with [] -> tl | _ -> let make_var s = make_atom ("'" ^ s) in let x = match l with [s] -> make_var s | l -> List (("(", ",", ")", plist), List.map make_var l) in x :: tl and prepend_type_args l tl = match l with [] -> tl | _ -> let x = match l with [t] -> format_type_expr t | l -> List (("(", ",", ")", plist), List.map format_type_expr l) in x :: tl and format_type_expr x = match x with Sum (_, l, a) -> append_annots a ( List ( ("[", "|", "]", llist), List.map format_variant l ) ) | Record (_, l, a) -> append_annots a ( List ( ("{", ";", "}", list), List.map format_field l ) ) | Tuple (_, l, a) -> append_annots a ( List ( ("(", "*", ")", lplist), List.map format_tuple_field l ) ) | List (_, t, a) -> format_type_name "list" [t] a | Option (_, t, a) -> format_type_name "option" [t] a | Nullable (_, t, a) -> format_type_name "nullable" [t] a | Shared (_, t, a) -> format_type_name "shared" [t] a | Wrap (_, t, a) -> format_type_name "wrap" [t] a | Name (_, (_, name, args), a) -> format_type_name name args a | Tvar (_, name) -> make_atom ("'" ^ name) and format_type_name name args a = append_annots a ( horizontal_sequence (prepend_type_args args [ make_atom name ]) ) and format_inherit t = horizontal_sequence [ make_atom "inherit"; format_type_expr t ] and format_tuple_field (_, x, a) = prepend_colon_annots a (format_type_expr x) and format_field x = match x with `Field (_, (k, fk, a), t) -> Label ( (horizontal_sequence0 [ append_annots a (make_atom (string_of_field k fk)); make_atom ":" ], label), format_type_expr t ) | `Inherit (_, t) -> format_inherit t and format_variant x = match x with Variant (_, (k, a), opt) -> let cons = append_annots a (make_atom k) in (match opt with None -> cons | Some t -> Label ( (cons, label), Label ( (make_atom "of", label), format_type_expr t ) ) ) | Inherit (_, t) -> format_inherit t in let format_full_module ((_, an), l) = Easy_format.List ( ("", "", "", rlist), List.map format_annot an @ List.map format_module_item l ) in format_full_module, format_type_name, format_type_expr let format ?(annot = default_annot) x = let f, _, _ = make_closures annot in f x let _default_format, default_format_type_name, default_format_type_expr = make_closures default_annot let string_of_type_name name args an = let x = default_format_type_name name args an in Easy_format.Pretty.to_string x let string_of_type_expr expr = let x = default_format_type_expr expr in Easy_format.Pretty.to_string x atd-2.1.0/atd/src/print.mli000066400000000000000000000013611357165332000154660ustar00rootroot00000000000000(** Pretty-printing of ATD data *) val default_annot : Ast.annot_section -> Easy_format.t val format : ?annot: (Ast.annot_section -> Easy_format.t) -> Ast.full_module -> Easy_format.t (** Pretty-printing. Use the functions of the [Easy_format.Pretty] module to convert an [Easy_format.t] into a string or add it to a channel or buffer. @param annot can be used to specify another way of formatting annotations. The default is available as [default_format_annot]. *) val string_of_type_name : string -> Ast.type_expr list -> Ast.annot -> string (** Convert a type name with its arguments and its annotations into a string. *) val string_of_type_expr : Ast.type_expr -> string atd-2.1.0/atd/src/reflect.ml000066400000000000000000000110161357165332000156030ustar00rootroot00000000000000(* Conversion of an ATD tree to OCaml source code for that value. *) open Import let print_loc buf (_, _) = bprintf buf "loc" let print_list f buf l = bprintf buf "["; List.iter (fun x -> bprintf buf "%a;\n" f x) l; bprintf buf "]" let print_opt f buf o = match o with None -> bprintf buf "None" | Some x -> bprintf buf "Some (%a)" f x let print_qstring buf s = bprintf buf "%S" s let print_prop_list buf l = print_list ( fun buf (s, (loc, o)) -> bprintf buf "(%S, (%a, %a))" s print_loc loc (print_opt print_qstring) o ) buf l let print_annot_list buf l = print_list ( fun buf (s, (loc, l)) -> bprintf buf "(%S, (%a, %a))" s print_loc loc print_prop_list l ) buf l let rec print_type_expr buf (x : Ast.type_expr) = match x with | Sum (loc, variant_list, annot_list) -> bprintf buf "`Sum (%a, %a, %a)" print_loc loc (print_list print_variant) variant_list print_annot_list annot_list | Record (loc, field_list, annot_list) -> bprintf buf "`Record (%a, %a, %a)" print_loc loc (print_list print_field) field_list print_annot_list annot_list | Tuple (loc, cell_list, annot_list) -> bprintf buf "`Tuple (%a, %a, %a)" print_loc loc (print_list print_cell) cell_list print_annot_list annot_list | List (loc, type_expr, annot_list) -> bprintf buf "`List (%a, %a, %a)" print_loc loc print_type_expr type_expr print_annot_list annot_list | Option (loc, type_expr, annot_list) -> bprintf buf "`Option (%a, %a, %a)" print_loc loc print_type_expr type_expr print_annot_list annot_list | Nullable (loc, type_expr, annot_list) -> bprintf buf "`Nullable (%a, %a, %a)" print_loc loc print_type_expr type_expr print_annot_list annot_list | Shared (loc, type_expr, annot_list) -> bprintf buf "`Shared (%a, %a, %a)" print_loc loc print_type_expr type_expr print_annot_list annot_list | Wrap (loc, type_expr, annot_list) -> bprintf buf "`Wrap (%a, %a, %a)" print_loc loc print_type_expr type_expr print_annot_list annot_list | Name (loc, type_inst, annot_list) -> bprintf buf "`Name (%a, %a, %a)" print_loc loc print_type_inst type_inst print_annot_list annot_list | Tvar (loc, string) -> bprintf buf "`Tvar (%a, %S)" print_loc loc string and print_cell buf (loc, x, a) = bprintf buf "(%a, %a, %a)" print_loc loc print_type_expr x print_annot_list a and print_variant buf x = match x with Variant (loc, (s, a), o) -> bprintf buf "`Variant (%a, (%S, %a), %a)" print_loc loc s print_annot_list a (print_opt print_type_expr) o | Inherit (loc, x) -> bprintf buf "`Inherit (%a, %a)" print_loc loc print_type_expr x and print_field buf x = match x with `Field (loc, (s, kind, a), x) -> bprintf buf "`Field (%a, (%S, %a, %a), %a)" print_loc loc s print_field_kind kind print_annot_list a print_type_expr x | `Inherit (loc, x) -> bprintf buf "`Inherit (%a, %a)" print_loc loc print_type_expr x and print_field_kind buf fk = Buffer.add_string buf (match fk with Required -> "`Required" | Optional -> "`Optional" | With_default -> "`With_default") and print_type_inst buf (loc, s, l) = bprintf buf "(%a, %S, %a)" print_loc loc s (print_list print_type_expr) l let print_module_item buf (Ast.Type (loc, (name, param, a), x)) = bprintf buf "`Type (%a, (%S, %a, %a), %a)" print_loc loc name (print_list print_qstring) param print_annot_list a print_type_expr x let print_module_body buf l = bprintf buf "[\n"; List.iter (fun x -> print_module_item buf x; bprintf buf ";\n" ) l; bprintf buf "]\n" let print_module_body_def buf name l = bprintf buf "\ let %s_body : Ast.module_body = let loc = Ast.dummy_loc in %a let %s = %s_body (* for backward compatibility with atd <= 1.0.1 *) " name print_module_body l name name let print_module_head_def buf name an = bprintf buf "\ let %s_head : Ast.module_head = let loc = Ast.dummy_loc in (loc, %a) " name print_annot_list an let print_full_module_def buf name ((_, an), l) = print_module_head_def buf name an; print_module_body_def buf name l; bprintf buf "\ let %s_full : Ast.full_module = (%s_head, %s_body) " name name name atd-2.1.0/atd/src/reflect.mli000066400000000000000000000004571357165332000157630ustar00rootroot00000000000000(** Conversion of an AST value into OCaml source code that creates this value *) val print_full_module_def : Buffer.t -> string -> Ast.full_module -> unit (** [print_full_module_def buf name x] prints OCaml source code that would construct the given ATD tree [x] and call it [name]. *) atd-2.1.0/atd/src/sort.ml000066400000000000000000000243431357165332000151550ustar00rootroot00000000000000(* Topological sort that doesn't give up on cycles: A --> B C --> D gives: [A] [B C] [D] B --> C C --> B The complexity of this algorithm is in O(N^2), although it is plenty fast for the application. TODO: use the Kosaraju–Sharir algorithm which is simpler and has a linear complexity. A good description of the algorithm is given here: http://scienceblogs.com/goodmath/2007/10/30/computing-strongly-connected-c/ *) open Import module type Param = sig type t type id val id : t -> id (* for error messages and debugging *) val to_string : id -> string end module Make (P : Param) = struct type id = P.id type node_state = Visited | Unvisited (* graph node with mutable labels *) type node = { id: P.id; value: P.t; mutable state: node_state; } (* all edges of the original graph *) type graph = { forward: (id, node list) Hashtbl.t; backward: (id, node list) Hashtbl.t; } (* subset of nodes on which iteration and set operations are possible (intersection, union, etc.) *) module S = Set.Make ( struct type t = node let compare a b = compare a.id b.id end ) let debug = ref false let print_nodes msg nodes = if !debug then printf "%s: %s\n%!" msg (String.concat " " (List.map (fun v -> P.to_string v.id) (S.elements nodes) ) ) (* Algorithm outline: Input: directed graph Output: a list of node groups sorted topologically, i.e. for any group A coming after group B and any node n_a in A and any node n_b in B, there is no edge going from n_b to n_a. ... such that the number of groups is maximum. Initialization: Build graph structure such that allows following edges both forward and backward. 1. root and leaf elimination: a leaf is a node without outgoing edges, a root is a node without incoming edges. 2. partitioning into strict ancestors (left), cycle (middle), and strict descendants (right), and other (independent): pick an processed node V (our pivot), determine the set of descendant nodes and the set of ancestor nodes by following edges from V respectively forward and backward. Nodes that belong both to the descendant set and to the ancestor set form a cycle with V and are removed from the graph. Strict ancestors are sorted starting from step 1, strict descendants are sorted starting from step 1. *) let get_neighbors v edges = try Hashtbl.find edges v.id with Not_found -> [] let filtered_neighbors v edges graph_nodes = let all = get_neighbors v edges in List.filter (fun neighbor -> S.mem neighbor graph_nodes) all let pick_one nodes = try let v = S.choose nodes in Some (v, S.remove v nodes) with Not_found -> None let add_list set l = List.fold_left (fun set v -> S.add v set) set l let is_root back_edges graph_nodes v = filtered_neighbors v back_edges graph_nodes = [] let eliminate_roots_recursively edges back_edges nodes = let rec aux sorted graph_nodes input_nodes = match pick_one input_nodes with | None -> List.rev_map (fun v -> false, S.singleton v) sorted, graph_nodes | Some (v, input_nodes) -> if is_root back_edges graph_nodes v then let sorted = v :: sorted in let children = filtered_neighbors v edges graph_nodes in let graph_nodes = S.remove v graph_nodes in let input_nodes = add_list input_nodes children in assert (not (S.mem v input_nodes)); aux sorted graph_nodes input_nodes else aux sorted graph_nodes input_nodes in aux [] nodes nodes let eliminate_roots graph nodes = eliminate_roots_recursively graph.forward graph.backward nodes let eliminate_leaves graph nodes = let sorted_leaves, remaining_nodes = eliminate_roots_recursively graph.backward graph.forward nodes in remaining_nodes, List.rev sorted_leaves (* Collect all nodes reachable from the root. Exclude the root unless it can be reached by some cycle. *) let visit edges start_node nodes = assert (S.for_all (fun v -> v.state = Unvisited) nodes); let visited = ref [] in let mark_visited v = v.state <- Visited; visited := v :: !visited in let clear_visited () = List.iter (fun v -> v.state <- Unvisited) !visited in let rec color acc v = match v.state with | Visited -> acc | Unvisited -> mark_visited v; List.fold_left (fun acc neighbor -> if S.mem neighbor nodes then let acc = S.add neighbor acc in color acc neighbor else acc ) acc (get_neighbors v edges) in let visited_excluding_root = color S.empty start_node in clear_visited (); visited_excluding_root let find_descendants graph pivot nodes = print_nodes "find_descendants" nodes; visit graph.forward pivot nodes let find_ancestors graph pivot nodes = print_nodes "find_ancestors" nodes; visit graph.backward pivot nodes let rec sort_subgraph graph nodes = print_nodes "sort_subgraph" nodes; let sorted_left, nodes = eliminate_roots graph nodes in let nodes, sorted_right = eliminate_leaves graph nodes in let sorted_middle = match pick_one nodes with | None -> [] | Some (pivot, _) -> partition graph pivot nodes in sorted_left @ sorted_middle @ sorted_right and partition graph pivot nodes = print_nodes "partition" nodes; let ( - ) = S.diff in let ancestors = find_ancestors graph pivot nodes in let descendants = find_descendants graph pivot nodes in let strict_ancestors = ancestors - descendants in let strict_descendants = descendants - ancestors in let cycle = S.inter descendants ancestors in let is_cyclic, pivot_group = if S.is_empty cycle then ( assert (not (S.mem pivot ancestors)); assert (not (S.mem pivot descendants)); false, S.singleton pivot ) else ( assert (S.mem pivot cycle); true, cycle ) in let other = nodes - pivot_group - strict_ancestors - strict_descendants in print_nodes "ancestors" ancestors; print_nodes "descendants" descendants; print_nodes "cycle" cycle; print_nodes "other" other; sort_subgraph graph strict_ancestors @ [ is_cyclic, pivot_group ] @ sort_subgraph graph strict_descendants @ sort_subgraph graph other (* could as well be inserted anywhere *) (* Data preparation and cleanup *) let sort l = let node_tbl = Hashtbl.create (2 * List.length l) in let make_node x = let id = P.id x in if not (Hashtbl.mem node_tbl id) then let v = { id; state = Unvisited; value = x; } in Hashtbl.add node_tbl id v in let get_node id = try Some (Hashtbl.find node_tbl id) with Not_found -> None in let make_edge edges v1 v2 = let l = try Hashtbl.find edges v1.id with Not_found -> [] in Hashtbl.replace edges v1.id (v2 :: l) in List.iter (fun (x, _) -> make_node x) l; let forward = Hashtbl.create (2 * List.length l) in let backward = Hashtbl.create (2 * List.length l) in List.iter (fun (x1, l) -> let v1 = match get_node (P.id x1) with | Some v -> v | None -> assert false in List.iter (fun id2 -> match get_node id2 with | None -> () | Some v2 -> make_edge forward v1 v2; make_edge backward v2 v1; ) l ) l; let graph = { forward; backward } in let nodes = Hashtbl.fold (fun _ v set -> S.add v set) node_tbl S.empty in let sorted_groups = sort_subgraph graph nodes in (* Export as lists *) List.map (fun (is_cyclic, set) -> is_cyclic, List.map (fun node -> node.value) (S.elements set) ) sorted_groups end (* Testing *) module Sorter = Make ( struct type t = int type id = int let id x = x let to_string x = string_of_int x end ) let rec in_order result a b = match result with | [] -> false | (_, l) :: ll -> if List.mem b l then false else if List.mem a l then List.exists (fun (_, l) -> List.mem b l) ll else in_order ll a b let rec in_same_cycle result a b = match result with | [] -> false | (cyclic, l) :: ll -> cyclic && List.mem a l && List.mem b l || in_same_cycle ll a b let not_in_cycle result x = List.exists (function | (false, [y]) when y = x -> true | _ -> false ) result let seq result a b = in_order result a b && not (in_order result b a) && not (in_same_cycle result a b) let cyc result a b = in_same_cycle result a b && not (in_order result a b) && not (in_order result b a) let sng result x = not_in_cycle result x let run_test1 () = Sorter.sort [ 1, [ 2 ]; 2, [ 3 ]; 3, [ 1 ]; ] let test1 () = let r = run_test1 () in assert (cyc r 1 2); assert (cyc r 2 3); assert (cyc r 1 3) let run_test2 () = Sorter.sort [ 1, [ 2 ]; 2, [ 3 ]; 3, []; 5, [ 6 ]; 4, [ 5 ]; 6, []; ] let test2 () = let r = run_test2 () in assert (seq r 1 2); assert (seq r 2 3); assert (seq r 4 5); assert (seq r 5 6); assert (sng r 3); assert (sng r 6) let run_test3 () = Sorter.sort [ 1, [ 2; 3 ]; 2, [ 3 ]; 3, [ 3; 4 ]; 4, [ 3; ]; 5, [ 6 ]; 6, [ 6; 1 ]; 5, [ 7 ]; 7, [ 8 ]; 8, [ 9 ]; 9, [ 0 ]; 10, [ 10 ]; 11, [ 12 ]; 12, [ 13 ]; 13, [ 11 ]; ] let test3 () = let r = run_test3 () in assert (not (sng r 0)); assert (not (seq r 0 1)); assert (not (seq r 1 0)); assert (not (cyc r 0 0)); assert (sng r 1); assert (seq r 1 2); assert (seq r 1 4); assert (seq r 1 3); assert (seq r 2 3); assert (cyc r 3 4); assert (sng r 5); assert (seq r 6 1); assert (sng r 7); assert (sng r 8); assert (sng r 9); assert (seq r 5 9); assert (cyc r 10 10); assert (cyc r 11 12); assert (cyc r 12 13); assert (cyc r 11 13) let test () = test1 (); test2 (); test3 () atd-2.1.0/atd/src/sort.mli000066400000000000000000000037711357165332000153300ustar00rootroot00000000000000(** Topological sort that doesn't give up on cycles. {v A --> B C --> D B --> C C --> B D --> E E --> E v} gives the following ordering: {v [A] [B C]* [D] [E]* v} where a group marked with a star is cyclic, i.e any member of the group can be reached from any other member of that group. This is used by atdgen to sort type definitions by dependency order, creating recursive groups only when needed. This makes ocamlopt significantly faster in certain pathological situations. Also it improves the clarity of the generated code and can be used to report cycles in a context where they are not allowed. Feel free to reuse outside of atdgen. The algorithm is outlined in the ml file. The interface of this module may change without notice. *) module type Param = sig type t (** Type of the nodes as specified by the user *) type id (** Node identifier that can be compared and hashed using the generic comparison and hashing functions of the standard library. Typically an int or a string. *) val id : t -> id (** User function to extract a node's unique identifier *) val to_string : id -> string (** User function to make a node identifier printable, used for debugging only. *) end module Make (P : Param) : sig val sort : (P.t * P.id list) list -> (bool * P.t list) list (** Partition the nodes of a directed graph into groups and sort these groups such that all edges going from one group to another point to the right, and such that each group has a single element or is a cycle. A cyclic group is marked as [true] while non-cyclic singletons are marked as [false]. A cycle is a set of nodes such that any node of the set can be reached from any other node of that set. All groups of more than one node are cyclic. Groups of one node may or may not be cyclic. *) (**/**) val debug : bool ref end (**/**) val test : unit -> unit atd-2.1.0/atd/src/util.ml000066400000000000000000000044021357165332000151350ustar00rootroot00000000000000let read_lexbuf ?(expand = false) ?keep_poly ?(xdebug = false) ?(inherit_fields = false) ?(inherit_variants = false) ?(pos_fname = "") ?(pos_lnum = 1) lexbuf = Lexer.init_fname lexbuf pos_fname pos_lnum; let head, body = Parser.full_module Lexer.token lexbuf in Check.check body; let body = if inherit_fields || inherit_variants then Inherit.expand_module_body ~inherit_fields ~inherit_variants body else body in let (body, original_types) = if expand then Expand.expand_module_body ?keep_poly ~debug: xdebug body else (body, Hashtbl.create 0) in ((head, body), original_types) let read_channel ?expand ?keep_poly ?xdebug ?inherit_fields ?inherit_variants ?pos_fname ?pos_lnum ic = let lexbuf = Lexing.from_channel ic in let pos_fname = if pos_fname = None && ic == stdin then Some "" else pos_fname in read_lexbuf ?expand ?keep_poly ?xdebug ?inherit_fields ?inherit_variants ?pos_fname ?pos_lnum lexbuf let load_file ?expand ?keep_poly ?xdebug ?inherit_fields ?inherit_variants ?pos_fname ?pos_lnum file = let ic = open_in file in let finally () = close_in_noerr ic in try let pos_fname = match pos_fname with None -> Some file | Some _ -> pos_fname in let ast = read_channel ?expand ?keep_poly ?xdebug ?inherit_fields ?inherit_variants ?pos_fname ?pos_lnum ic in finally (); ast with e -> finally (); raise e let load_string ?expand ?keep_poly ?xdebug ?inherit_fields ?inherit_variants ?pos_fname ?pos_lnum s = let lexbuf = Lexing.from_string s in read_lexbuf ?expand ?keep_poly ?xdebug ?inherit_fields ?inherit_variants ?pos_fname ?pos_lnum lexbuf module Tsort = Sort.Make ( struct type t = Ast.module_item type id = string (* type name *) let id def = let Ast.Type (_, (name, _, _), _) = def in name let to_string name = name end ) let tsort l0 = let ignorable = [ "unit"; "bool"; "int"; "float"; "string"; "abstract" ] in let l = List.map ( fun def -> let Ast.Type (_, (_, _, _), x) = def in let deps = Ast.extract_type_names ~ignorable x in (def, deps) ) l0 in List.rev (Tsort.sort l) atd-2.1.0/atd/src/util.mli000066400000000000000000000067501357165332000153160ustar00rootroot00000000000000(** Top-level utilities *) val read_lexbuf : ?expand:bool -> ?keep_poly:bool -> ?xdebug:bool -> ?inherit_fields:bool -> ?inherit_variants:bool -> ?pos_fname:string -> ?pos_lnum:int -> Lexing.lexbuf -> Ast.full_module * Expand.original_types (** Read an ATD file from a lexbuf. See also [read_channel], [load_file] and [load_string]. If expand is true, the second part of the return value will contain a hash table mapping the types generated during monomorphization back to their original polymorphic types. See {!Expand.original_types} for more information about this table. If expand is false, the value will be the empty hash table. @param expand Perform monomorphization by creating specialized type definitions starting with an underscore. Default is false. See also {!Expand}. This corresponds to the [-x] option of [atdcat]. @param keep_poly Preserve left-hand-side of all original type definitions instead of removing parametrized definitions. This option only applies when [expand = true]. Default is false. See also {!Expand}. This corresponds to the [-xk] option of [atdcat]. @param xdebug Debugging option producing meaningful but non ATD-compliant type names when new types names are created. Default is false. This corresponds to the [-xd] option of [atdcat]. @param inherit_fields Expand [inherit] statements in record types. Default is false. See also {!Atd_inherit}. This corresponds to the [-if] option of [atdcat]. @param inherit_variants Expand [inherit] statements in sum types. Default is false. See also {!Atd_inherit}. This corresponds to the [-iv] option of [atdcat]. @param pos_fname Set the file name for use in error messages. Default is [""]. @param pos_lnum Set the number of the first line for use in error messages. Default is [1]. *) val read_channel : ?expand:bool -> ?keep_poly:bool -> ?xdebug:bool -> ?inherit_fields:bool -> ?inherit_variants:bool -> ?pos_fname:string -> ?pos_lnum:int -> in_channel -> Ast.full_module * Expand.original_types (** Read an ATD file from an [in_channel]. Options: see [read_lexbuf]. The default [pos_fname] is set to [""] when appropriate. *) val load_file : ?expand:bool -> ?keep_poly:bool -> ?xdebug:bool -> ?inherit_fields:bool -> ?inherit_variants:bool -> ?pos_fname:string -> ?pos_lnum:int -> string -> Ast.full_module * Expand.original_types (** Read an ATD file. Options: see [read_lexbuf]. The default [pos_fname] is the given input file name. *) val load_string : ?expand:bool -> ?keep_poly:bool -> ?xdebug:bool -> ?inherit_fields:bool -> ?inherit_variants:bool -> ?pos_fname:string -> ?pos_lnum:int -> string -> Ast.full_module * Expand.original_types (** Read ATD data from a string. Options: see [read_lexbuf]. *) val tsort : Ast.module_body -> (bool * Ast.module_body) list (** Topological sort for dependency analysis. [tsort] splits definitions into mutually-recursive groups, ordered such that each group may only depend on type definitions of its own group or previous groups. The boolean flags indicate groups of one or more mutually recursive definitions. *) atd-2.1.0/atd/src/version.ml000066400000000000000000000000341357165332000156420ustar00rootroot00000000000000let version = "%%VERSION%%" atd-2.1.0/atd/test/000077500000000000000000000000001357165332000140165ustar00rootroot00000000000000atd-2.1.0/atd/test/dune000066400000000000000000000001761357165332000147000ustar00rootroot00000000000000(executables (libraries atd) (names unit_tests)) (alias (name runtest) (package atd) (action (run ./unit_tests.exe))) atd-2.1.0/atd/test/test.atd000066400000000000000000000044221357165332000154710ustar00rootroot00000000000000(* -*- tuareg -*- *) type x = y type y = x (* conflict or inheritance or anything: unspecified. *) type ('a, 'b, 'c) yyy = int type z = [ | X | Y of x | Z of z ] type ('a, 'b, 'c) tiptoptiptop = [ Foo | Fioo of int | Bar of z | Aaaaaaaaaaaaa ] type kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk = int option type ('a, 'b, 'ccccccccccccccccccccc) r = { x :int; y:float option; adfadfafa : (int list option,'ccccccccccccccccccccc,'ccccccccccccccccccccc) tiptoptiptop; llllllllllllllllllllllllll: kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk; ?z : int option; ~t : int; } type tuple = (z * z * tuple option * kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk * z * z * tuple option * kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk) type tuple2 = (int * float) type singleton = (int) type zero_tuple = () type 'a i1 = [ inherit 'a j2 | I1 ] type 'a i2 = [ inherit z | I2 of 'a ] type i = int i1 type 'b j2 = 'b i2 type i3 = [ inherit i | I1 of float | Y ] type r1 = { x1 : int } type r2 = { inherit r1; x2 : int } type nullable_string = string nullable type pair = ( : int * : bool) type 'a abs = abstract type int_abs = int abs type 'a l = 'a list type 'a int_l = int l type int_list = int list type int_array = int list type 'a recur = { cyc : 'a recur option } type 'a ta = [ Ta of 'a ] type int_ta = int ta type int_ta2 = int ta type timestamp = string wrap atd-2.1.0/atd/test/test2.atd000066400000000000000000000015411357165332000155520ustar00rootroot00000000000000type z = abstract list type 'a t = int type x = float t type 'a l = [ Nil | Cons of ('a * 'a l) ] type int_l = int l type float_l = float l type tup = (int l * float_l) type ('a, 'b) tbl = ('a * 'b) list list type 'a string_tbl = (string, 'a) tbl type string_bool_tbl = bool string_tbl type 'a b = 'a a type 'a a = 'a b type c = c a b a type 'id gen_profile = { id : 'id; name : string option; age : int option } type basic_profile = int gen_profile type profile_enhancements = { credit_card_number : string } type ('id, 'self) nested_profile = { inherit 'id gen_profile; sub_profiles : 'self list } type profile = { inherit (int, profile) nested_profile; inherit profile_enhancements } (* expands to: type profile = { id: int; name: string option; age: int option; sub_profiles: profile list; credit_card_number: string } *) atd-2.1.0/atd/test/unit_tests.ml000066400000000000000000000000631357165332000165500ustar00rootroot00000000000000let main () = Atd.Sort.test () let () = main () atd-2.1.0/atdcat/000077500000000000000000000000001357165332000135275ustar00rootroot00000000000000atd-2.1.0/atdcat/atdcat.ml000066400000000000000000000111271357165332000153230ustar00rootroot00000000000000open Atd.Import let html_of_doc loc s = let doc = Atd.Doc.parse_text loc s in Atd.Doc.html_of_doc doc let format_html_comments ((section, (_, l)) as x) = let comment s = let comment = "(*html " ^ s ^ "*)" in Easy_format.Atom (comment, Easy_format.atom) in match section with | "doc" -> begin match List.assoc "html" l with | Some (_, Some s) -> comment s | Some _ | None -> begin match List.assoc "text" l with | Some (loc, Some s) -> comment (html_of_doc loc s) | Some _ | None -> Atd.Print.default_annot x end end | _ -> Atd.Print.default_annot x let print_atd ~html_doc ast = let annot = if html_doc then Some format_html_comments else None in let pp = Atd.Print.format ?annot ast in Easy_format.Pretty.to_channel stdout pp; print_newline () let print_ml ~name ast = let buf = Buffer.create 1000 in Atd.Reflect.print_full_module_def buf name ast; print_string (Buffer.contents buf); print_newline () let strip all sections x = let filter = if all then fun _ -> [] else List.filter (fun (name, _) -> not (List.mem name sections)) in Atd.Ast.map_all_annot filter x let parse ~expand ~keep_poly ~xdebug ~inherit_fields ~inherit_variants ~strip_all ~strip_sections files = let l = List.map ( fun file -> fst ( Atd.Util.load_file ~expand ~keep_poly ~xdebug ~inherit_fields ~inherit_variants file ) ) files in let heads, bodies = List.split l in let first_head = (* heads in other files than the first one are tolerated but ignored *) match heads with x :: _ -> x | [] -> (Atd.Ast.dummy_loc, []) in let m = first_head, List.flatten bodies in strip strip_all strip_sections m let print ~html_doc ~out_format ast = let f = match out_format with `Atd -> print_atd ~html_doc | `Ocaml name -> print_ml ~name in f ast let split_on_comma = Re.Str.split_delim (Re.Str.regexp ",") let () = let expand = ref false in let keep_poly = ref false in let xdebug = ref false in let inherit_fields = ref false in let inherit_variants = ref false in let strip_sections = ref [] in let strip_all = ref false in let out_format = ref `Atd in let html_doc = ref false in let files = ref [] in let options = [ "-x", Arg.Set expand, " make type expressions monomorphic"; "-xk", Arg.Unit (fun () -> expand := true; keep_poly := true), " keep parametrized type definitions and imply -x. Default is to return only monomorphic type definitions"; "-xd", Arg.Unit (fun () -> expand := true; xdebug := true), " debug mode implying -x"; "-i", Arg.Unit (fun () -> inherit_fields := true; inherit_variants := true), " expand all `inherit' statements"; "-if", Arg.Set inherit_fields, " expand `inherit' statements in records"; "-iv", Arg.Set inherit_variants, " expand `inherit' statements in sum types"; "-ml", Arg.String (fun s -> out_format := `Ocaml s), " output the ocaml code of the ATD abstract syntax tree"; "-html-doc", Arg.Set html_doc, " replace directly by (*html ... *) or replace by (*html ... *) where the contents are formatted as HTML using

, and 

.
          This is suitable input for \"caml2html -ext html:cat\"
          which converts ATD files into HTML.";

    "-strip",
    Arg.String (fun s -> strip_sections := split_on_comma s @ !strip_sections),
    "NAME1[,NAME2,...]
          remove all annotations of the form ,
          , etc.";

    "-strip-all", Arg.Set strip_all,
    "
          remove all annotations";

    "-version",
    Arg.Unit (fun () ->
                print_endline Atd.Version.version;
                exit 0),
    "
          print the version of atd and exit";
  ]
  in
  let msg = sprintf "Usage: %s FILE" Sys.argv.(0) in
  Arg.parse options (fun file -> files := file :: !files) msg;
  try
    let ast =
      parse
          ~expand: !expand
          ~keep_poly: !keep_poly
          ~xdebug: !xdebug
          ~inherit_fields: !inherit_fields
          ~inherit_variants: !inherit_variants
          ~strip_all: !strip_all
          ~strip_sections: !strip_sections
          !files
    in
    print ~html_doc: !html_doc ~out_format: !out_format ast
  with
      Atd.Ast.Atd_error s ->
        flush stdout;
        eprintf "%s\n%!" s
    | e -> raise e
atd-2.1.0/atdcat/dune000066400000000000000000000001251357165332000144030ustar00rootroot00000000000000(executables
 (names atdcat)
 (public_names atdcat)
 (libraries atd)
 (package atd))
atd-2.1.0/atdgen-codec-runtime.opam000066400000000000000000000023611357165332000171450ustar00rootroot00000000000000# This file is generated by dune, edit dune-project instead
opam-version: "2.0"
synopsis: "Runtime for atdgen generated bucklescript converters"
description: """
This library contains the types that are used by atdgen's
bucklescript backend"""
maintainer: ["Rudi Grinberg "]
authors: [
  "Martin Jambon "
  "David Sheets "
  "Rudi Grinberg "
  "Ivan Jager "
  "Jeff Meister "
  "Carmelo Piccione "
  "Raman Varabets "
  "Mathieu Baudet "
  "Rauan Mayemir "
  "Louis Roché "
  "Brendan Long "
  "Christophe Troestler "
  "Vincent Bernardoff "
  "haoyang "
]
license: "MIT"
homepage: "https://github.com/ahrefs/atd"
bug-reports: "https://github.com/ahrefs/atd/issues"
depends: [
  "dune" {>= "1.11"}
  "ocaml" {>= "4.02"}
]
build: [
  ["dune" "subst"] {pinned}
  [
    "dune"
    "build"
    "-p"
    name
    "-j"
    jobs
    "@install"
    "@runtest" {with-test}
    "@doc" {with-doc}
  ]
]
dev-repo: "git+https://github.com/ahrefs/atd.git"
atd-2.1.0/atdgen-codec-runtime/000077500000000000000000000000001357165332000162655ustar00rootroot00000000000000atd-2.1.0/atdgen-codec-runtime/src/000077500000000000000000000000001357165332000170545ustar00rootroot00000000000000atd-2.1.0/atdgen-codec-runtime/src/decode.ml000066400000000000000000000051171357165332000206350ustar00rootroot00000000000000type 'a t = Json.t -> 'a

let make f = f

exception DecoderError

let decode f json = f json

let unit = function
  | `Null -> ()
  | _ -> raise DecoderError

let bool = function
  | `Bool b -> b
  | _ -> raise DecoderError

let int = function
  | `Int i -> i
  | _ -> raise DecoderError

let float = function
  | `Float f -> f
  | _ -> raise DecoderError

let char = function
  | `String s when String.length s = 1 -> s.[0]
  | _ -> raise DecoderError

let string = function
  | `String s -> s
  | _ -> raise DecoderError

let list f = function
  | `List l -> List.map f l
  | _ -> raise DecoderError

let array f = function
  | `List l -> Array.map f (Array.of_list l)
  | _ -> raise DecoderError

let obj_list f = function
  | `Assoc l -> List.map (fun (k, v) -> k, f v) l
  | _ -> raise DecoderError

let obj_array f = function
  | `Assoc l -> Array.map (fun (k, v) -> k, f v) (Array.of_list l)
  | _ -> raise DecoderError

let optional f j =
  match f j with
  | exception DecoderError -> None
  | v -> Some v

let map f c j = f (c j)

let field s f = function
  | `Assoc v -> f (List.assoc s v)
  | _ -> raise DecoderError

let fieldOptional s f = function
  | `Assoc v ->
      begin match List.assoc s v with
        | exception Not_found -> None
        | v -> Some (f v)
      end
  | _ -> raise DecoderError

let fieldDefault s default f =
  fieldOptional s f
  |> map (function
    | None -> default
    | Some s -> s)

let tuple1 a = function
  | `Tuple [w]
  | `List [w] -> a w
  | _ -> raise DecoderError

let tuple2 a b = function
  | `Tuple [w ; x]
  | `List [w ; x] -> (a w, b x)
  | _ -> raise DecoderError

let tuple3 a b c = function
  | `Tuple [w; x; y]
  | `List [w; x; y] -> (a w, b x, c y)
  | _ -> raise DecoderError

let tuple4 a b c d = function
  | `Tuple [w; x; y; z]
  | `List [w; x; y; z] -> (a w, b x, c y, d z)
  | _ -> raise DecoderError

let enum l = function
  | `Variant (s, None)
  | `String s ->
      begin match List.assoc s l with
        | exception Not_found -> raise DecoderError
        | `Single a -> a
        | `Decode _ -> raise DecoderError
      end
  | `Variant (s, Some args)
  | `List [`String s; args] ->
      begin match List.assoc s l with
        | exception Not_found -> raise DecoderError
        | `Single _ -> raise DecoderError
        | `Decode d -> decode d args
      end
  | _ -> raise DecoderError

let option_as_constr f =
  enum
    [ "None", `Single None
    ; "Some", `Decode (map (fun x -> Some x) f)
    ]

let nullable f = function
  | `Null -> None
  | x -> Some (f x)

let adapter (normalize: Json.t -> Json.t) (reader: 'a t) json =
  reader (normalize json)
atd-2.1.0/atdgen-codec-runtime/src/decode.mli000066400000000000000000000021161357165332000210020ustar00rootroot00000000000000type 'a t = Json.t -> 'a

val make : (Json.t -> 'a) -> 'a t

val decode : 'a t -> Json.t -> 'a

val unit : unit t
val bool : bool t
val int : int t
val float : float t
val char : char t
val string : string t

val optional : 'a t -> 'a option t
val list : 'a t -> 'a list t
val array : 'a t -> 'a array t
val obj_list : 'a t -> (string * 'a) list t
val obj_array : 'a t -> (string * 'a) array t

(* a field that should be present *)
val field : string -> 'a t -> 'a t

(* a field that turns into a an optional value when absent *)
val fieldDefault : string -> 'a -> 'a t -> 'a t

(* a field that returns None when is absent *)
val fieldOptional : string -> 'a t -> 'a option t

val map : ('a -> 'b) -> 'a t -> 'b t

val tuple1 : 'a t -> 'a t
val tuple2 : 'a t -> 'b t -> ('a * 'b) t
val tuple3 : 'a t -> 'b t -> 'c t -> ('a * 'b * 'c) t
val tuple4 : 'a t -> 'b t -> 'c t -> 'd t -> ('a * 'b * 'c * 'd) t

val enum : (string * [`Single of 'a | `Decode of 'a t]) list -> 'a t

val option_as_constr : 'a t -> 'a option t

val nullable : 'a t -> 'a option t

val adapter: (Json.t -> Json.t) -> 'a t -> 'a t
atd-2.1.0/atdgen-codec-runtime/src/dune000066400000000000000000000001131357165332000177250ustar00rootroot00000000000000(library
 (name atdgen_codec_runtime)
 (public_name atdgen-codec-runtime))
atd-2.1.0/atdgen-codec-runtime/src/encode.ml000066400000000000000000000040631357165332000206460ustar00rootroot00000000000000type 'a t = 'a -> Json.t

let make f = f

let encode f x = f x

let bool b = `Bool b
let char c = `String (String.make 1 c)
let string s = `String s
let unit () = `Null
let float f = `Float f
let int i = `Int i

let list f xs = `List (List.map f xs)
let array f xs = `List (Array.to_list (Array.map f xs))

let int32 s = `String (Int32.to_string s)
let int64 s = `String (Int64.to_string s)

type ('a, 'b) spec =
  { name: string
  ; data: 'a
  ; encode: 'b t
  }

type 'a field_spec =
  | Optional of ('a option, 'a) spec * 'a option
  | Required of ('a, 'a) spec * 'a option

type field = F : 'a field_spec -> field

let field ?default encode ~name data =
  F (Required (
    { name
    ; data
    ; encode
    }, default
  ))

let field_o ?default encode ~name data =
  F (Optional (
    { name
    ; data
    ; encode
    }, default
  ))

let obj fields =
  `Assoc (
    List.fold_left (fun acc (F f) ->
      match f with
      | Required ({ name; data; encode}, None) ->
          (name, encode data)::acc
      | Required ({ name; data; encode}, Some default) ->
          if default = data then
            acc
          else
            (name, encode data)::acc
      | Optional ({ name; data; encode}, default) ->
          match data, default with
          | None, _ -> acc
          | Some s, Some default ->
              if s = default then
                acc
              else
                (name, encode s)::acc
          | Some s, None ->
              (name, encode s)::acc
    ) [] fields
  )

let tuple1 f x = `Tuple [f x]
let tuple2 f g (w, x) = `Tuple [f w; g x]
let tuple3 f g h (w, x, y) = `Tuple [f w; g x; h y]
let tuple4 f g h i (w, x, y, z) = `Tuple [f w; g x; h y;i z]

let constr0 s = `Variant (s, None)
let constr1 s f x = `Variant (s, Some (f x))

let contramap f g b = g (f b)

let nullable f = function
  | None -> `Null
  | Some s -> f s

let option_as_constr f = function
  | None -> `Variant ("None", None)
  | Some s -> `Variant ("Some", Some (f s))

let adapter (restore: Json.t -> Json.t) (writer: 'a t) x =
  let encoded = writer x in
  restore encoded
atd-2.1.0/atdgen-codec-runtime/src/encode.mli000066400000000000000000000016371357165332000210230ustar00rootroot00000000000000type 'a t = 'a -> Json.t

val make : ('a -> Json.t) -> 'a t

val encode : 'a t -> 'a -> Json.t

val unit : unit t
val string : string t
val float : float t
val int : int t
val bool : bool t
val char : char t

val list : 'a t -> 'a list t
val array : 'a t -> 'a array t

val int32 : int32 t
val int64 : int64 t

type field

val field : ?default:'a -> 'a t -> name:string -> 'a -> field
val field_o : ?default:'a -> 'a t -> name:string -> 'a option -> field

val obj : field list -> Json.t

val tuple1 : 'a t -> 'a t
val tuple2 : 'a t -> 'b t -> ('a * 'b) t
val tuple3 : 'a t -> 'b t -> 'c t -> ('a * 'b * 'c) t
val tuple4 : 'a t -> 'b t -> 'c t -> 'd t -> ('a * 'b * 'c * 'd) t

val constr0 : string -> Json.t
val constr1 : string -> 'a t -> 'a -> Json.t

val contramap : ('b -> 'a) -> 'a t -> 'b t

val nullable : 'a t -> 'a option t

val option_as_constr : 'a t -> 'a option t

val adapter: (Json.t -> Json.t) -> 'a t -> 'a t
atd-2.1.0/atdgen-codec-runtime/src/json.ml000066400000000000000000000004571357165332000203650ustar00rootroot00000000000000
type t =
  [ `Assoc of (string * t) list
  | `Bool of bool
  | `Float of float
  | `Int of int
  | `Intlit of string
  | `List of t list
  | `Null
  | `String of string
  | `Tuple of t list
  | `Variant of string * t option ]

let constr0 s = `Variant (s, None)

let constr1 s a = `Variant (s, Some a)
atd-2.1.0/atdgen-codec-runtime/src/json.mli000066400000000000000000000004351357165332000205320ustar00rootroot00000000000000
type t =
  [ `Assoc of (string * t) list
  | `Bool of bool
  | `Float of float
  | `Int of int
  | `Intlit of string
  | `List of t list
  | `Null
  | `String of string
  | `Tuple of t list
  | `Variant of string * t option ]

val constr0 : string -> t
val constr1 : string -> t -> t
atd-2.1.0/atdgen-codec-runtime/src/json_adapter.ml000066400000000000000000000021001357165332000220500ustar00rootroot00000000000000(* Json adapters. See .mli. *)

module type S = sig
  val normalize : Json.t -> Json.t
  val restore : Json.t -> Json.t
end

module Type_field = struct
  module type Param = sig
    val type_field_name : string
  end

  module Make (Param : Param) : S = struct
    open Param

    let normalize (x : Json.t) : Json.t =
      match x with
      | `Assoc fields ->
          (match List.assoc type_field_name fields with
           | `String type_ -> `List [ `String type_; x ]
           | exception Not_found -> x
           | _ -> x (* malformed *)
          )
      | `String _ as x -> x
      | malformed -> malformed

    let restore (x : Json.t) : Json.t =
      match x with
      | `List [ `String type_; `Assoc fields ] ->
          let fields =
            (type_field_name, `String type_) ::
            List.filter (fun (k, _) -> k <> type_field_name) fields
          in
          `Assoc fields
      | `String _ as x -> x
      | malformed -> malformed
  end

  module Default_param : Param = struct
    let type_field_name = "type"
  end

  include Make (Default_param)
end
atd-2.1.0/atdgen-codec-runtime/src/json_adapter.mli000066400000000000000000000032511357165332000222310ustar00rootroot00000000000000(** Json adapters and tools for the user to make their own json adapters
    for common situations.

    Json adapters are used to rewrite json node into a form compatible
    with atdgen's conventions.
*)

(** Module signature required of any json adapter.
    For example, an ATD annotation
    [ Json.t

  (** Convert an atd-compliant json tree into a real json tree. *)
  val restore : Json.t -> Json.t
end

(** Support for json objects that contain a field that indicates
    the type of that object.
    The following
{[
{
  "type": "User",
  "id": "abc123",
  "age": 52
}
]}
        gets converted into a pair
{[
[
  "User",
  {
    "type": "User",
    "id": "abc123",
    "age": 52
  }
]
]}
        A corresponding ATD type definition is
{[
type obj = [
  | User of user
  | ...
] 

type user = {
  id: string;
  age: int;

  (* The following field definition is supported, albeit useless. *)
  type_ : string;
}
]}
*)
module Type_field : sig
  module type Param = sig
    val type_field_name : string
  end

  (** Default parameters, using [type_field_name = "type"]. *)
  module Default_param : Param

  (** Default adapter assuming a ["type"] field. *)
  include S

  (** Functor, allowing the use of a custom parameter:
{[
module Kind = Type_field.Make (struct type_field_name = "kind" end)
]}
  *)
  module Make (Param : Param) : S
end
atd-2.1.0/atdgen-cppo/000077500000000000000000000000001357165332000144705ustar00rootroot00000000000000atd-2.1.0/atdgen-cppo/README.md000066400000000000000000000030271357165332000157510ustar00rootroot00000000000000`cppo-json` is a preprocessor that replaces embedded type definition 
directives with OCaml type definitions and JSON
serialization/deserialization code.

`atdgen-cppo` is the script that reads type definitions from stdin and
generates OCaml code. It takes options allowing users to pick what
kind of code needs to be generated (type definitions, JSON
serialization, Biniou serialization, validators).

Example
-------

Sample input:

```
$ cat example.ml
#ext json
type mytype = string list
#endext
let data = [ "Hello"; "world" ]
let () = print_endline (J.string_of_mytype data)
```

How to view the OCaml code produced by cppo-json:

```
$ cppo-json < example.ml | less
```

How to compile an OCaml program:

```
$ ocamlfind opt -o example \
    -pp cppo-json \
    -package atdgen -linkpkg \
    example.ml
```

cppo-json ships with atdgen-cppo and is shorthand for the following command:

```
cppo -x "json:atdgen-cppo t j v"
```

where `t` stands for "type definitions", `j` stands for "JSON", and
`v` stands for "validators".

See also:
```
$ cppo-json --help
$ atdgen-cppo --help
$ cppo --help
```


Documentation
-------------

Documentation is provided by the `--help` option of each command.

Direct dependencies
-------------------

* [atdgen](https://github.com/MyLifeLabs/atdgen)
* [cppo](https://github.com/mjambon/cppo)

Installation
------------

It's just two shell scripts. You can copy them by hand to the
directory of your choice or run:

```
$ make install   # installs into $HOME/bin
```

or

```
$ BINDIR=/path/to/bin make install
```
atd-2.1.0/atdgen-cppo/atdgen-cppo000077500000000000000000000031341357165332000166200ustar00rootroot00000000000000#! /bin/sh -e
version=1.0.0

self="$0"
usage () {
    echo "\
Usage: $self [t] [b] [j] [v]

atdgen-cppo makes it possible to use atdgen to derive code from ATD 
type definitions embedded in OCaml source files rather than in
separate .atd files. This is similar to how json-static is used,
except that the preprocessor is not camlp4 but the simpler program cppo.

Modes:
  t  produce a module T containing OCaml type definitions translated from ATD
  b  produce a module B containing OCaml code for biniou serialization
  j  produce a module J containing OCaml code JSON serialization
  v  produce a module V containing OCaml code for validation

Typical usage:

  \$ cat example.ml
  #ext json
  type mytype = string list
  #endext
  let data = [ \"Hello\"; \"world\" ]
  let () = print_endline (J.string_of_mytype data)

  \$ ocamlfind opt -o example \\
    -pp 'cppo -x \"json:$self t j\"' \\
    -package atdgen -linkpkg example.ml

  \$ ./example
  [\"Hello\",\"world\"]
" >&2
}

case "$1" in
    -h|-help|--help) usage; exit 0 ;;
    *) ;;
esac

tmp=$(tempfile -p ml- -s -atdgen-cppo.ml)
cat > $tmp

fail () {
    rm -f $tmp
    exit 1
}

# CPPO_FIRST_LINE is off by one in cppo 0.9.1.
# Should be fixed in cppo rather than here.
gen () {
    echo "module $1 = ("
    atdgen \
      -pos-fname "$CPPO_FILE" \
      -pos-lnum $(( $CPPO_FIRST_LINE + 1 )) \
      -$2 < $tmp || fail
    echo ")"
}

while [ $# != 0 ]; do
    case "$1" in
        t) gen T t ;;
        b) gen B b ;;
        j) gen J j ;;
        v) gen V v ;;
        --help|-help) usage; exit 0 ;;
        *) usage; exit 2
    esac
    shift
done

rm -f $tmp
atd-2.1.0/atdgen-cppo/cppo-json000077500000000000000000000021161357165332000163260ustar00rootroot00000000000000#! /bin/sh

usage () {
    echo "\
Usage: cppo-json [cppo arguments]

cppo-json processes an OCaml file written with embedded type definitions
directives and replaces them by OCaml type definitions and JSON
serialization/deserialization code.

Sample input:

  \$ cat example.ml
  #ext json
  type mytype = string list
  #endext
  let data = [ \"Hello\"; \"world\" ]
  let () = print_endline (J.string_of_mytype data)

How to view the OCaml code produced by cppo-json:

  \$ cppo-json < example.ml | less

How to compile an OCaml program:

  \$ ocamlfind opt -o example \\
      -pp cppo-json \\
      -package atdgen -linkpkg \\
      example.ml

cppo-json ships with atdgen-cppo and is shorthand for the following command:

  cppo -x \"json:atdgen-cppo t j v\"

where 't' stands for 'type definitions', 'j' stands for 'JSON', and
'v' stands for \"validators\".

See also:
  atdgen-cppo --help
  cppo --help
" >&2
}

case "$1" in
    --help|-help) usage; exit 0 ;;
    *)
esac

cppo -x "json:atdgen-cppo t j v" "$@"

case $? in
    0) ;;
    *)
        echo "cppo-json failed" >&2
        exit 2
esac
atd-2.1.0/atdgen-cppo/dune000066400000000000000000000001121357165332000153400ustar00rootroot00000000000000(install
 (section bin)
 (package atdgen)
 (files atdgen-cppo cppo-json))
atd-2.1.0/atdgen-cppo/example.ml000066400000000000000000000001751357165332000164600ustar00rootroot00000000000000#ext json
type mytype = string list
#endext
let data = [ "Hello"; "world" ]
let () = print_endline (J.string_of_mytype data)
atd-2.1.0/atdgen-runtime.opam000066400000000000000000000024401357165332000160700ustar00rootroot00000000000000# This file is generated by dune, edit dune-project instead
opam-version: "2.0"
synopsis: "Runtime library for code generated by atdgen"
description: """
This package should be used only in conjunction with the stdgen code
generator"""
maintainer: ["Rudi Grinberg "]
authors: [
  "Martin Jambon "
  "David Sheets "
  "Rudi Grinberg "
  "Ivan Jager "
  "Jeff Meister "
  "Carmelo Piccione "
  "Raman Varabets "
  "Mathieu Baudet "
  "Rauan Mayemir "
  "Louis Roché "
  "Brendan Long "
  "Christophe Troestler "
  "Vincent Bernardoff "
  "haoyang "
]
license: "MIT"
homepage: "https://github.com/ahrefs/atd"
bug-reports: "https://github.com/ahrefs/atd/issues"
depends: [
  "ocaml" {>= "4.02"}
  "dune" {>= "1.11"}
  "yojson" {>= "1.7.0"}
  "biniou" {>= "1.0.6"}
  "re"
]
build: [
  ["dune" "subst"] {pinned}
  [
    "dune"
    "build"
    "-p"
    name
    "-j"
    jobs
    "@install"
    "@runtest" {with-test}
    "@doc" {with-doc}
  ]
]
dev-repo: "git+https://github.com/ahrefs/atd.git"
atd-2.1.0/atdgen-runtime/000077500000000000000000000000001357165332000152125ustar00rootroot00000000000000atd-2.1.0/atdgen-runtime/src/000077500000000000000000000000001357165332000160015ustar00rootroot00000000000000atd-2.1.0/atdgen-runtime/src/dune000066400000000000000000000001321357165332000166530ustar00rootroot00000000000000(library
 (name atdgen_runtime)
 (public_name atdgen-runtime)
 (libraries biniou yojson))
atd-2.1.0/atdgen-runtime/src/json_adapter.ml000066400000000000000000000111041357165332000210010ustar00rootroot00000000000000(* Json adapters. See .mli. *)

module type S = sig
  val normalize : Yojson.Safe.t -> Yojson.Safe.t
  val restore : Yojson.Safe.t -> Yojson.Safe.t
end

module Type_field = struct
  module type Param = sig
    val type_field_name : string
  end

  module Make (Param : Param) : S = struct
    open Yojson.Safe

    open Param

    let normalize (x : t) : t =
      match x with
      | `Assoc fields ->
          (match List.assoc type_field_name fields with
           | `String type_ -> `List [ `String type_; x ]
           | exception Not_found -> x
           | _ -> x (* malformed *)
          )
      | `String type_ as x -> x
      | malformed -> malformed

    let restore (x : t) : t =
      match x with
      | `List [ `String type_; `Assoc fields ] ->
          let fields =
            (type_field_name, `String type_) ::
            List.filter (fun (k, v) -> k <> type_field_name) fields
          in
          `Assoc fields
      | `String type_ as x -> x
      | malformed -> malformed
  end

  module Default_param : Param = struct
    let type_field_name = "type"
  end

  include Make (Default_param)
end

module One_field = struct
  open Yojson.Safe

  let normalize (x : t) : t =
    match x with
    | `Assoc [name, value] -> `List [`String name; value]
    | `String _ as x -> x
    | malformed -> malformed

  let restore (x : t) : t =
    match x with
    | `List [`String name; value] -> `Assoc [name, value]
    | `String _ as x -> x
    | malformed -> malformed
end

module Type_and_value_fields = struct
  module type Param = sig
    val type_field_name : string
    val value_field_name : string
    val known_tags : (string list * string) option
  end

  module Make (Param : Param) : S = struct
    open Yojson.Safe
    open Param

    let is_known_tag =
      match known_tags with
      | None -> (fun _ -> true)
      | Some (l, _) ->
          let tbl = Hashtbl.create (2 * List.length l) in
          List.iter (fun x -> Hashtbl.add tbl x ()) l;
          Hashtbl.mem tbl

    let is_catch_all_tag =
      match known_tags with
      | None -> (fun _ -> false)
      | Some (_, s) -> ((=) s)

    let catch_all_tag () =
      match known_tags with
      | None -> assert false
      | Some (_, s) -> s

    let wrap_variant type_ value =
      let variant = `List [`String type_; value] in
      if is_known_tag type_ then
        variant
      else
        `List [ `String (catch_all_tag ()); variant ]

    let wrap_enum type_ =
      if is_known_tag type_ then
        `String type_
      else
        `List [ `String (catch_all_tag ()); `Null ]

    let normalize (x : t) : t =
      let open Yojson.Safe.Util in
      match x with
      | `Assoc fields ->
          let type_ = member type_field_name x |> to_string in
          let found = ref false in
          let fields =
            List.map (fun ((k, v) as field) ->
              if k = value_field_name then (
                found := true;
                (k, wrap_variant type_ v)
              )
              else
                field
            ) fields
          in
          let fields =
            if !found then
              fields
            else
              (value_field_name, wrap_enum type_) :: fields
          in
          `Assoc fields
      | malformed -> malformed

    let unwrap_value (x : t) =
      match x with
      | `String tag -> (tag, None)
      | `List [`String tag; v] ->
          if is_catch_all_tag tag then (
            match v with
            | `List [`String real_tag; `Null] -> (real_tag, None)
            | `List [`String real_tag; real_v] -> (real_tag, Some real_v)
            | _ -> failwith ("Malformed json field " ^ value_field_name)
          )
          else
            (tag, Some v)
      | malformed -> failwith ("Malformed json field " ^ value_field_name)

    let restore (x : t) : t =
      match x with
      | `Assoc fields ->
          let type_ = ref None in
          let fields =
            List.fold_right (fun ((k, tagged) as field) acc ->
              if k = value_field_name then (
                let tag, opt_value = unwrap_value tagged in
                type_ := Some tag;
                match opt_value with
                | None -> acc
                | Some v -> (value_field_name, v) :: acc
              )
              else if k = type_field_name then
                acc
              else
                field :: acc
              ) fields []
          in
          let fields =
            match !type_ with
            | None -> fields
            | Some tag -> (type_field_name, `String tag) :: fields
          in
          `Assoc fields
      | malformed -> malformed
  end
end
atd-2.1.0/atdgen-runtime/src/json_adapter.mli000066400000000000000000000107671357165332000211700ustar00rootroot00000000000000(** Json adapters and tools for the user to make their own json adapters
    for common situations.

    Json adapters are used to rewrite json node into a form compatible
    with atdgen's conventions.
*)

(** Module signature required of any json adapter.
    For example, an ATD annotation
    [ Yojson.Safe.t

  (** Convert an atd-compliant json tree into a real json tree. *)
  val restore : Yojson.Safe.t -> Yojson.Safe.t
end

(** Support for json objects that contain a field that indicates
    the type of that object.
    The following
{[
{
  "type": "User",
  "id": "abc123",
  "age": 52
}
]}
        gets converted into a pair
{[
[
  "User",
  {
    "type": "User",
    "id": "abc123",
    "age": 52
  }
]
]}
        A corresponding ATD type definition is
{[
type obj = [
  | User of user
  | ...
] 

type user = {
  id: string;
  age: int;

  (* The following field definition is supported, albeit useless. *)
  type_ : string;
}
]}
*)
module Type_field : sig
  module type Param = sig
    val type_field_name : string
  end

  (** Default parameters, using [type_field_name = "type"]. *)
  module Default_param : Param

  (** Default adapter assuming a ["type"] field. *)
  include S

  (** Functor, allowing the use of a custom parameter:
{[
module Kind = Type_field.Make (struct type_field_name = "kind" end)
]}
  *)
  module Make (Param : Param) : S
end

(** Support for objects with a single field whose name indicates the type
    of the value.
    For instance,
{[
{
  "User": {
    "id": "abc123",
    "age": 52
  }
}
]}
    gets converted into
{[
[
  "User",
  {
    "id": "abc123",
    "age": 52
  }
]
]}
    An ATD type definition for this is
{[
type obj = [
  | User of user
  | ...
] 

type user = {
  id: string;
  age: int;
}
]}
*)
module One_field : S

(** Support for the retired tag_field feature.
    This converts the following
{[
{
  "id": "abc123",
  "type": "User",
  "payload": 17
}
]}
    into
{[
{
  "id": "abc123",
  "type": "User",
  "payload": [ "User", 17 ]
}
]}
    As illustrated, two parameters need to be specified: the name
    of the field that holds the tag of the variant
    (["type"] in the example)
    and the name of the field that holds the value associated with
    that tag (["payload"] in the example).

    If the value is missing, we'll use the representation of an enum,
    i.e. a json string:
{[
{
  "id": "abc124",
  "type": "Event",
}
]}
    becomes
{[
{
  "id": "abc124",
  "type": "Event",
  "payload": "Event"
}
]}
    Additionally, a catch-all case is supported if [known_tags] is specified.
    Given the following ATD type definitions:
{[
type t = {
  id: string;
  payload: payload;
} 

type payload = [
  | User of int
  | Event

  (* catch-all *)
  | Unknown of (string * json nullable)
]
]}
    and the module [My_adapter] defined as follows:
{[
module My_adapter = Atdgen_runtime.Json_adapter.Type_and_value_fields.Make(
  struct
    let type_field_name = "type"
    let value_field_name = "payload"
    let known_tags = Some ["User"; "Event"]
  end
)
]}
    and given the following json input:
{[
{
  "id": "abc124",
  "type": "Group",
  "payload": {}
}
]}
    we obtain this normalized json, compatible with the type definitions:
{[
{
  "id": "abc124",
  "payload": ["Unknown", ["Group", {}]]
}
]}
    If there's no payload, it is treated as if it were [null].
    Given the following:
{[
{
  "id": "abc124",
  "type": "Thing"
}
]}
    we get this normalized json:
{[
{
  "id": "abc124",
  "payload": ["Unknown", ["Thing", null]]
}
]}
*)
module Type_and_value_fields : sig
  module type Param = sig
    (** The name of the json field containing the type of the value
        as a json string. *)
    val type_field_name : string

    (** The name of the json field containing the value. *)
    val value_field_name : string

    (** Optionally indicate a set of known tags and a catch-all tag.
        This allows unknown tags/values coming from the original json
        to be wrapped under a catch-all tag. *)
    val known_tags : (string list * string) option
  end

  (** Functor needed to produce a module using the correct parameters. *)
  module Make (Param : Param) : S
end

atd-2.1.0/atdgen-runtime/src/ob_run.ml000066400000000000000000000167451357165332000176340ustar00rootroot00000000000000[@@@ocaml.warning "-32"]

(*
  Runtime library
*)

open Printf

exception Error of string

(*
  Error messages
*)
let error s = raise (Error s)

let read_error () =
  error "Read error"

let read_error_at ib =
  error (sprintf "Read error (%i)" ib.Bi_inbuf.i_pos)

let tag_error tag s =
  error (sprintf "Found wrong tag %i for %s" tag s)

let unsupported_variant h has_arg =
  error (sprintf "Unsupported variant (hash=%i, arg=%B)" h has_arg)


let missing_tuple_fields len req_fields =
  let missing =
    List.fold_right (
      fun i acc -> if i >= len then i :: acc else acc
    ) req_fields []
  in
  error (sprintf "Missing tuple field%s %s"
           (if List.length missing > 1 then "s" else "")
           (String.concat ", " (List.map string_of_int missing)))


let missing_fields bit_fields field_names =
  let acc = ref [] in
  for z = Array.length field_names - 1 downto 0 do
    let i = z / 31 in
    let j = z mod 31 in
    if bit_fields.(i) land (1 lsl j) = 0 then
      acc := field_names.(z) :: !acc
  done;
  error (sprintf "Missing record field%s %s"
           (if List.length !acc > 1 then "s" else "")
           (String.concat ", " !acc))


(*
  Readers
*)

let get_unit_reader tag =
  if tag = Bi_io.unit_tag then
    Bi_io.read_untagged_unit
  else
    tag_error tag "unit"

let read_unit ib =
  if Bi_io.read_tag ib = Bi_io.unit_tag then
    Bi_io.read_untagged_unit ib
  else
    read_error_at ib

let get_bool_reader tag =
  if tag = Bi_io.bool_tag then
    Bi_io.read_untagged_bool
  else
    tag_error tag "bool"

let read_bool ib =
  if Bi_io.read_tag ib = Bi_io.bool_tag then
    Bi_io.read_untagged_bool ib
  else
    read_error_at ib

let get_int_reader tag =
  match tag with
      1 -> Bi_io.read_untagged_int8
    | 2 -> Bi_io.read_untagged_int16
    | 16 -> Bi_io.read_untagged_uvint
    | 17 -> Bi_io.read_untagged_svint
    | _ -> tag_error tag "int"

let read_int ib =
  match Bi_io.read_tag ib with
      1 -> Bi_io.read_untagged_int8 ib
    | 2 -> Bi_io.read_untagged_int16 ib
    | 16 -> Bi_io.read_untagged_uvint ib
    | 17 -> Bi_io.read_untagged_svint ib
    | _ -> read_error_at ib

let get_char_reader tag =
  if tag = Bi_io.int8_tag then
    Bi_io.read_untagged_char
  else
    tag_error tag "char"

let read_char ib =
  if Bi_io.read_tag ib = Bi_io.int8_tag then
    Bi_io.read_untagged_char ib
  else
    read_error_at ib

let get_int16_reader tag =
  if tag = Bi_io.int16_tag then
    Bi_io.read_untagged_int16
  else
    tag_error tag "int16"

let read_int16 ib =
  if Bi_io.read_tag ib = Bi_io.int16_tag then
    Bi_io.read_untagged_int16 ib
  else
    read_error_at ib

let get_int32_reader tag =
  if tag = Bi_io.int32_tag then
    Bi_io.read_untagged_int32
  else
    tag_error tag "int32"

let read_int32 ib =
  if Bi_io.read_tag ib = Bi_io.int32_tag then
    Bi_io.read_untagged_int32 ib
  else
    read_error_at ib

let get_int64_reader tag =
  if tag = Bi_io.int64_tag then
    Bi_io.read_untagged_int64
  else
    tag_error tag "int64"

let read_int64 ib =
  if Bi_io.read_tag ib = Bi_io.int64_tag then
    Bi_io.read_untagged_int64 ib
  else
    read_error_at ib

let get_float32_reader tag =
  if tag = Bi_io.float32_tag then
    Bi_io.read_untagged_float32
  else
    tag_error tag "float32"

let get_float64_reader tag =
  if tag = Bi_io.float64_tag then
    Bi_io.read_untagged_float64
  else
    tag_error tag "float64"

let get_float_reader = get_float64_reader

let read_float32 ib =
  if Bi_io.read_tag ib = Bi_io.float32_tag then
    Bi_io.read_untagged_float32 ib
  else
    read_error_at ib

let read_float64 ib =
  if Bi_io.read_tag ib = Bi_io.float64_tag then
    Bi_io.read_untagged_float64 ib
  else
    read_error_at ib

let read_float = read_float64

let get_string_reader tag =
  if tag = Bi_io.string_tag then
    Bi_io.read_untagged_string
  else
    tag_error tag "string"

let read_string ib =
  if Bi_io.read_tag ib = Bi_io.string_tag then
    Bi_io.read_untagged_string ib
  else
    read_error_at ib

let read_array_value get_reader ib =
  let len = Bi_vint.read_uvint ib in
  if len = 0 then [| |]
  else
    let reader = get_reader (Bi_io.read_tag ib) in
    let a = Array.make len (reader ib) in
    for i = 1 to len - 1 do
      Array.unsafe_set a i (reader ib)
    done;
    a

let read_list_value get_reader ib =
  Array.to_list (read_array_value get_reader ib)

let get_array_reader get_reader tag =
  if tag = Bi_io.array_tag then
    read_array_value get_reader
  else
    tag_error tag "array"

let get_list_reader get_reader tag =
  if tag = Bi_io.array_tag then
    fun ib -> Array.to_list (read_array_value get_reader ib)
  else
    tag_error tag "list"

let read_array get_reader ib =
  if Bi_io.read_tag ib = Bi_io.array_tag then
    read_array_value get_reader ib
  else
    read_error_at ib

let read_list read ib =
  Array.to_list (read_array read ib)


(*
  Writers
*)

let write_tagged tag write buf x =
  Bi_io.write_tag buf tag;
  write buf x

let write_untagged_option write buf x =
  match x with
      None -> Bi_io.write_numtag buf 0 false
    | Some x ->
        Bi_io.write_numtag buf 0 true;
        write buf x

let write_option write buf x =
  Bi_io.write_tag buf Bi_io.num_variant_tag;
  write_untagged_option write buf x

let array_init2 len x f =
  if len = 0 then [| |]
  else
    let a = Array.make len (f 0 x) in
    for i = 1 to len - 1 do
      Array.unsafe_set a i (f i x)
    done;
    a

let array_init3 len x y f =
  if len = 0 then [| |]
  else
    let a = Array.make len (f 0 x y) in
    for i = 1 to len - 1 do
      Array.unsafe_set a i (f i x y)
    done;
    a

let array_iter2 f x a =
  for i = 0 to Array.length a - 1 do
    f x (Array.unsafe_get a i)
  done

let array_iter3 f x y a =
  for i = 0 to Array.length a - 1 do
    f x y (Array.unsafe_get a i)
  done


let rec list_iter2 f x = function
    [] -> ()
  | y :: l ->
      f x y;
      list_iter2 f x l

let rec list_iter3 f x y = function
    [] -> ()
  | z :: l ->
      f x y z;
      list_iter3 f x y l


let write_untagged_array cell_tag write buf a =
  let len = Array.length a in
  Bi_vint.write_uvint buf len;
  if len > 0 then (
    Bi_io.write_tag buf cell_tag;
    array_iter2 write buf a
  )

let write_array cell_tag write buf a =
  Bi_io.write_tag buf Bi_io.array_tag;
  write_untagged_array cell_tag write buf a

let write_untagged_list cell_tag write buf l =
  let len = List.length l in
  Bi_vint.write_uvint buf len;
  if len > 0 then (
    Bi_io.write_tag buf cell_tag;
    list_iter2 write buf l
  )

let write_list cell_tag write buf l =
  Bi_io.write_tag buf Bi_io.array_tag;
  write_untagged_list cell_tag write buf l

(*
  shortcut for getting the tag of a polymorphic variant since
  biniou uses the same representation
  (usefulness?)
*)
let get_poly_tag (x : [> ]) =
  let r = Obj.repr x in
  if Obj.is_block r then
    (Obj.obj (Obj.field r 0) : int)
  else
    (Obj.obj r : int)

(* We want an identity function that is not inlined *)
type identity_t = { mutable _identity : 'a. 'a -> 'a }
let identity_ref = { _identity = (fun x -> x) }
let identity x = identity_ref._identity x

(*
  Checking at runtime that our assumptions on unspecified compiler behavior
  still hold.
*)

type t = {
  _a : int option;
  _b : int;
}

let create () =
  { { _a = None; _b = Array.length Sys.argv } with _a = None }

let test () =
  let r = create () in
  let v = Some 17 in
  Obj.set_field (Obj.repr r) 0 (Obj.repr v);
  let safe_r = identity r in
  (* r._a is inlined by ocamlopt and equals None
     because the field is supposed to be immutable. *)
  assert (safe_r._a = v)

let () = test ()

(************************************)
atd-2.1.0/atdgen-runtime/src/ob_run.mli000066400000000000000000000040471357165332000177750ustar00rootroot00000000000000(** OCaml-Biniou runtime library. *)

[@@@ocaml.warning "-32"]

exception Error of string


val missing_fields : int array -> string array -> 'a
val missing_tuple_fields : int -> int list -> 'a


val write_untagged_option
  : (Bi_outbuf.t -> 'a -> unit)
  -> Bi_outbuf.t
  -> 'a option
  -> unit

val write_untagged_list
  : Bi_io.node_tag
  -> (Bi_outbuf.t -> 'a -> unit)
  -> Bi_outbuf.t
  -> 'a list
  -> unit

val write_untagged_array
  : Bi_io.node_tag
  -> (Bi_outbuf.t -> 'a -> unit)
  -> Bi_outbuf.t
  -> 'a array
  -> unit

val get_list_reader
  : (Bi_io.node_tag -> Bi_inbuf.t -> 'a)
  -> Bi_io.node_tag
  -> Bi_inbuf.t
  -> 'a list

val get_array_reader
  : (Bi_io.node_tag -> Bi_inbuf.t -> 'a)
  -> Bi_io.node_tag
  -> Bi_inbuf.t
  -> 'a array

val read_list : (Bi_io.node_tag -> Bi_inbuf.t -> 'a) -> Bi_inbuf.t -> 'a list

val unsupported_variant : int -> bool -> 'a

val read_error_at : Bi_inbuf.t -> 'a


val read_int : Bi_inbuf.t -> int
val read_char : Bi_inbuf.t -> char
val read_bool : Bi_inbuf.t -> bool
val read_string : Bi_inbuf.t -> string
val read_float32 : Bi_inbuf.t -> float
val read_float64 : Bi_inbuf.t -> float
val read_int64 : Bi_inbuf.t -> int64
val read_int32 : Bi_inbuf.t -> int32
val read_array : (Bi_io.node_tag -> Bi_inbuf.t -> 'a) -> Bi_inbuf.t -> 'a array
val read_array_value
  : (Bi_io.node_tag -> Bi_inbuf.t -> 'a)
  -> Bi_inbuf.t
  -> 'a array

val get_unit_reader : Bi_io.node_tag -> Bi_inbuf.t -> unit
val get_char_reader : Bi_io.node_tag -> Bi_inbuf.t -> char
val get_bool_reader : Bi_io.node_tag -> Bi_inbuf.t -> bool
val get_string_reader : Bi_io.node_tag -> Bi_inbuf.t -> string
val get_float64_reader : Bi_io.node_tag -> Bi_inbuf.t -> float
val get_float32_reader : Bi_io.node_tag -> Bi_inbuf.t -> float
val get_int64_reader : Bi_io.node_tag -> Bi_inbuf.t -> int64
val get_int32_reader : Bi_io.node_tag -> Bi_inbuf.t -> int32
val get_int_reader : Bi_io.node_tag -> Bi_inbuf.t -> int

val read_error : unit -> 'a


val array_iter2 : ('a -> 'b -> unit) -> 'a -> 'b array -> unit
val array_init2 : int -> 'a -> (int -> 'a -> 'b) -> 'b array
atd-2.1.0/atdgen-runtime/src/oj_run.ml000066400000000000000000000152071357165332000176340ustar00rootroot00000000000000(*
  Runtime library for JSON
*)

open Printf

type 'a write = Bi_outbuf.t -> 'a -> unit

exception Error of string

(*
  Error messages
*)
let error s = raise (Error s)

let error_with_line p s =
  let s2 =
    match p.Yojson.Lexer_state.fname with
      Some f -> sprintf "File %s, line %i:\n%s" f p.Yojson.Lexer_state.lnum s
    | None -> sprintf "Line %i:\n%s" p.Yojson.Lexer_state.lnum s
  in
  raise (Error s2)


let list_iter f sep x l =
  let rec aux f sep x = function
      [] -> ()
    | y :: l ->
        sep x;
        f x y;
        aux f sep x l
  in
  match l with
      [] -> ()
    | y :: l ->
        f x y;
        aux f sep x l

let array_iter f sep x a =
  let n = Array.length a in
  if n > 0 then (
    f x (Array.unsafe_get a 0);
    for i = 1 to n - 1 do
      sep x;
      f x (Array.unsafe_get a i)
    done
  )

let write_comma ob =
  Bi_outbuf.add_char ob ','

let write_list write_item ob l =
  Bi_outbuf.add_char ob '[';
  list_iter write_item write_comma ob l;
  Bi_outbuf.add_char ob ']'

let write_array write_item ob a =
  Bi_outbuf.add_char ob '[';
  array_iter write_item write_comma ob a;
  Bi_outbuf.add_char ob ']'

let write_assoc_list write_key write_item ob l =
  Bi_outbuf.add_char ob '{';
  list_iter (
    fun ob (k, v) ->
      write_key ob k;
      Bi_outbuf.add_char ob ':';
      write_item ob v
  ) write_comma ob l;
  Bi_outbuf.add_char ob '}'

let write_assoc_array write_key write_item ob l =
  Bi_outbuf.add_char ob '{';
  array_iter (
    fun ob (k, v) ->
      write_key ob k;
      Bi_outbuf.add_char ob ':';
      write_item ob v
  ) write_comma ob l;
  Bi_outbuf.add_char ob '}'


let write_option write_item ob = function
    None -> Bi_outbuf.add_string ob "<\"None\">"
  | Some x ->
      Bi_outbuf.add_string ob "<\"Some\":";
      write_item ob x;
      Bi_outbuf.add_string ob ">"

let write_std_option write_item ob = function
    None -> Bi_outbuf.add_string ob "\"None\""
  | Some x ->
      Bi_outbuf.add_string ob "[\"Some\",";
      write_item ob x;
      Bi_outbuf.add_string ob "]"

let write_nullable write_item ob = function
    None -> Bi_outbuf.add_string ob "null"
  | Some x -> write_item ob x

let write_int8 ob x =
  Yojson.Safe.write_int ob (int_of_char x)

let write_int32 ob x =
  Bi_outbuf.add_string ob (Int32.to_string x)

let write_int64 ob x =
  Bi_outbuf.add_string ob (Int64.to_string x)

let min_float = float min_int
let max_float = float max_int

let write_float_as_int ob x =
  if x >= min_float && x <= max_float then
    Yojson.Safe.write_int ob
      (int_of_float (if x < 0. then x -. 0.5 else x +. 0.5))
  else
    match classify_float x with
        FP_normal
      | FP_subnormal
      | FP_zero -> Bi_outbuf.add_string ob (Printf.sprintf "%.0f" x)
      | FP_infinite -> error "Cannot convert inf or -inf into a JSON int"
      | FP_nan -> error "Cannot convert NaN into a JSON int"

type 'a read = Yojson.lexer_state -> Lexing.lexbuf -> 'a

let read_null p lb =
  Yojson.Safe.read_space p lb;
  Yojson.Safe.read_null p lb

let read_bool p lb =
  Yojson.Safe.read_space p lb;
  Yojson.Safe.read_bool p lb

let read_int p lb =
  Yojson.Safe.read_space p lb;
  Yojson.Safe.read_int p lb

let read_int8 p lb =
  Yojson.Safe.read_space p lb;
  Yojson.Safe.read_int8 p lb

let read_int32 p lb =
  Yojson.Safe.read_space p lb;
  Yojson.Safe.read_int32 p lb

let read_int64 p lb =
  Yojson.Safe.read_space p lb;
  Yojson.Safe.read_int64 p lb

let read_number p lb =
  Yojson.Safe.read_space p lb;
  Yojson.Safe.read_number p lb

let read_string p lb =
  Yojson.Safe.read_space p lb;
  Yojson.Safe.read_string p lb

let read_list read_item p lb =
  Yojson.Safe.read_space p lb;
  Yojson.Safe.read_list read_item p lb

let read_array read_item p lb =
  Yojson.Safe.read_space p lb;
  Yojson.Safe.read_array read_item p lb

let read_assoc_list_rev read_key read_item p lb =
  Yojson.Safe.read_space p lb;
  let read acc k p lb = (k, read_item p lb) :: acc in
  Yojson.Safe.read_abstract_fields read_key read [] p lb

let read_assoc_list read_key read_item p lb =
  List.rev (read_assoc_list_rev read_key read_item p lb)

let array_of_rev_list l =
  match l with
      [] -> [| |]
    | x :: tl ->
        let len = List.length l in
        let a = Array.make len x in
        let r = ref tl in
        for i = len - 2 downto 0 do
          a.(i) <- List.hd !r;
          r := List.tl !r
        done;
        a

let read_assoc_array read_key read_item p lb =
  array_of_rev_list (read_assoc_list_rev read_key read_item p lb)

let read_until_field_value p lb =
  Yojson.Safe.read_space p lb;
  Yojson.Safe.read_colon p lb;
  Yojson.Safe.read_space p lb

let missing_tuple_fields p len req_fields =
  let missing =
    List.fold_right (
      fun i acc -> if i >= len then i :: acc else acc
    ) req_fields []
  in
  error_with_line p (sprintf "Missing tuple field%s %s"
           (if List.length missing > 1 then "s" else "")
           (String.concat ", " (List.map string_of_int missing)))

let missing_field p field_name =
  error_with_line p (sprintf "Missing record field %s" field_name)

let missing_fields p bit_fields field_names =
  let acc = ref [] in
  for z = Array.length field_names - 1 downto 0 do
    let i = z / 31 in
    let j = z mod 31 in
    if bit_fields.(i) land (1 lsl j) = 0 then
      acc := field_names.(z) :: !acc
  done;
  error_with_line p (sprintf "Missing record field%s %s"
           (if List.length !acc > 1 then "s" else "")
           (String.concat ", " !acc))

let invalid_variant_tag p s =
  error_with_line p (sprintf "Unsupported variant %S" s)

let read_with_adapter normalize reader p lb =
  let ast = Yojson.Safe.read_json p lb in
  let ast' = normalize ast in
  let s' = Yojson.Safe.to_string ast' in
  let lb' = Lexing.from_string s' in
  reader p lb'

let write_with_adapter restore writer ob x =
  let ob_tmp = Bi_outbuf.create 1024 in
  writer ob_tmp x;
  let s_tmp = Bi_outbuf.contents ob_tmp in
  let ast = Yojson.Safe.from_string s_tmp in
  let ast' = restore ast in
  Yojson.Safe.to_outbuf ob ast'

(* We want an identity function that is not inlined *)
type identity_t = { mutable _identity : 'a. 'a -> 'a }
let identity_ref = { _identity = (fun x -> x) }
let identity x = identity_ref._identity x

(*
  Checking at runtime that our assumptions on unspecified compiler behavior
  still hold.
*)

type t = {
  _a : int option;
  _b : int;
}

let create () =
  { { _a = None; _b = Array.length Sys.argv } with _a = None }

let test () =
  let r = create () in
  let v = Some 17 in
  Obj.set_field (Obj.repr r) 0 (Obj.repr v);
  let safe_r = identity r in
  (* r._a is inlined by ocamlopt and equals None
     because the field is supposed to be immutable. *)
  assert (safe_r._a = v)

let () = test ()

(************************************)
atd-2.1.0/atdgen-runtime/src/oj_run.mli000066400000000000000000000030701357165332000200000ustar00rootroot00000000000000(** OCaml-Json runtime library. *)

exception Error of string

type 'a write = Bi_outbuf.t -> 'a -> unit

val error : string -> _

val write_list : 'a write -> 'a list write
val write_array : 'a write -> 'a array write
val write_float_as_int : float write
val write_assoc_list : 'a write -> 'b write -> ('a * 'b) list write
val write_assoc_array : 'a write -> 'b write -> ('a * 'b) array write
val write_option : 'a write -> 'a option write
val write_std_option : 'a write -> 'a option write
val write_nullable : 'a write -> 'a option write
val write_int8 : char write
val write_int32 : int32 write
val write_int64 : int64 write

type 'a read = Yojson.lexer_state -> Lexing.lexbuf -> 'a

val read_null : unit read
val read_bool : bool read
val read_int : int read
val read_int8 : char read
val read_int32 : int32 read
val read_int64 : int64 read
val read_string : string read
val read_array : 'a read -> 'a array read
val read_assoc_list : 'a read -> 'b read -> ('a * 'b) list read
val read_assoc_array : 'a read -> 'b read -> ('a * 'b) array read
val read_until_field_value : unit read
val read_list : 'a read -> 'a list read
val read_number : float read
val invalid_variant_tag : Yojson.Lexer_state.t -> string -> _

val missing_tuple_fields : Yojson.lexer_state -> int -> int list -> _
val missing_field : Yojson.lexer_state -> string -> _
val missing_fields : Yojson.lexer_state -> int array -> string array -> _

val write_with_adapter :
  (Yojson.Safe.t -> Yojson.Safe.t) -> ('a write) -> ('a write)

val read_with_adapter :
  (Yojson.Safe.t -> Yojson.Safe.t) -> ('a read) -> ('a read)
atd-2.1.0/atdgen-runtime/src/ov_run.ml000066400000000000000000000011041357165332000176370ustar00rootroot00000000000000let validate_list f path l =
  let rec loop f path i = function
    | [] -> None
    | x :: l ->
        let subpath = `Index i :: path in
        match f subpath x with
            None -> loop f path (i+1) l
          | err -> err
  in
  loop f path 0 l

let validate_array f path a =
  let rec loop f path a len i =
    if i >= len then None
    else
      match f (`Index i :: path) a.(i) with
          None -> loop f path a len (i+1)
        | err -> err
  in
  loop f path a (Array.length a) 0

let validate_option f path = function
    None -> None
  | Some x -> f path x
atd-2.1.0/atdgen-runtime/src/ov_run.mli000066400000000000000000000005501357165332000200140ustar00rootroot00000000000000(** Runtime library for OCaml validators. *)

val validate_list
  : (([> `Index of int ] as 'a) list -> 'b -> 'c option)
  -> 'a list
  -> 'b list
  -> 'c option

val validate_array
  : (([> `Index of int ] as 'a) list -> 'b -> 'c option)
  -> 'a list
  -> 'b array
  -> 'c option

val validate_option : ('a -> 'b -> 'c option) -> 'a -> 'b option -> 'c option
atd-2.1.0/atdgen-runtime/src/util.ml000066400000000000000000000136421357165332000173160ustar00rootroot00000000000000
type 'a ocaml_array = 'a array

let input_file fname read =
  let ic = open_in_bin fname in
  try
    let x = read ic in
    close_in ic;
    x
  with e ->
    close_in_noerr ic;
    raise e

let output_file fname write =
  let oc = open_out_bin fname in
  try
    write oc;
    close_out oc
  with e ->
    close_out_noerr oc;
    raise e

module Biniou =
struct
  type 'a reader = Bi_inbuf.t -> 'a
  type 'a writer = Bi_outbuf.t -> 'a -> unit

  let from_channel ?len ?(shrlen = 0) read ic =
    let ib = Bi_inbuf.from_channel ?len ~shrlen ic in
    read ib

  let from_file ?len ?(shrlen = 0) read fname =
    input_file fname (fun ic -> from_channel ?len ~shrlen read ic)

  let to_channel ?len ?(shrlen = 0) write oc x =
    let ob = Bi_outbuf.create_channel_writer ?len ~shrlen oc in
    write ob x;
    Bi_outbuf.flush_channel_writer ob

  let to_file ?len ?(shrlen = 0) write fname x =
    output_file fname (fun oc -> to_channel ?len ~shrlen write oc x)
end

module Json =
struct
  type 'a reader = Yojson.Safe.lexer_state -> Lexing.lexbuf -> 'a
  type 'a writer = Bi_outbuf.t -> 'a -> unit

  let finish ls lexbuf =
    Yojson.Safe.read_space ls lexbuf;
    if not (Yojson.Safe.read_eof lexbuf) then
      Yojson.json_error "Junk after end of JSON value"

  let from_lexbuf ?(stream = false) read ls lexbuf =
    Yojson.Safe.read_space ls lexbuf;

    let x =
      if Yojson.Safe.read_eof lexbuf then
        raise Yojson.End_of_input
      else
        read ls lexbuf
    in

    if not stream then
      finish ls lexbuf;

    x

  let from_string ?buf ?fname ?lnum read s =
    let lexbuf = Lexing.from_string s in
    let ls = Yojson.Safe.init_lexer ?buf ?fname ?lnum () in
    from_lexbuf read ls lexbuf

  let from_channel ?buf ?fname ?lnum read ic =
    let lexbuf = Lexing.from_channel ic in
    let ls = Yojson.Safe.init_lexer ?buf ?fname ?lnum () in
    from_lexbuf read ls lexbuf

  let from_file ?buf ?fname:src ?lnum read fname =
    let fname0 =
      match src with
          None -> fname
        | Some s -> s
    in
    input_file fname (fun ic -> from_channel ?buf ~fname:fname0 ?lnum read ic)

  let stream_from_lexbuf ?(fin = fun () -> ()) read ls lexbuf =
    let stream = Some true in
    let f _ =
      try Some (from_lexbuf ?stream read ls lexbuf)
      with
          Yojson.End_of_input ->
            fin ();
            None
        | e ->
            (try fin () with _ -> ());
            raise e
    in
    Stream.from f

  let stream_from_string ?buf ?fin ?fname ?lnum read ic =
    let lexbuf = Lexing.from_string ic in
    let ls = Yojson.Safe.init_lexer ?buf ?fname ?lnum () in
    stream_from_lexbuf ?fin read ls lexbuf

  let stream_from_channel ?buf ?fin ?fname ?lnum read ic =
    let lexbuf = Lexing.from_channel ic in
    let ls = Yojson.Safe.init_lexer ?buf ?fname ?lnum () in
    stream_from_lexbuf ?fin read ls lexbuf

  let stream_from_file ?buf ?(fin = fun () -> ()) ?fname:src ?lnum read fname =
    let fname0 =
      match src with
          None -> fname
        | Some s -> s
    in
    let ic = open_in_bin fname in
    let fin () = close_in_noerr ic; fin () in
    stream_from_channel ?buf ~fin ~fname:fname0 ?lnum read ic

  let list_from_string ?buf ?fin ?fname ?lnum read ic =
    let stream = stream_from_string ?buf ?fin ?fname ?lnum read ic in
    let acc = ref [] in
    Stream.iter (fun x -> acc := x :: !acc) stream;
    List.rev !acc

  let list_from_channel ?buf ?fin ?fname ?lnum read ic =
    let stream = stream_from_channel ?buf ?fin ?fname ?lnum read ic in
    let acc = ref [] in
    Stream.iter (fun x -> acc := x :: !acc) stream;
    List.rev !acc

  let list_from_file ?buf ?fname:src ?lnum read fname =
    let fname0 =
      match src with
          None -> fname
        | Some s -> s
    in
    let ic = open_in_bin fname in
    let fin () = close_in_noerr ic in
    list_from_channel ?buf ~fin ~fname:fname0 ?lnum read ic

  let to_string ?(len = 1024) write x =
    let ob = Bi_outbuf.create len in
    write ob x;
    Bi_outbuf.contents ob

  let to_channel ?len write oc x = Biniou.to_channel ?len ~shrlen:0 write oc x
  let to_file ?len write fname x = Biniou.to_file ?len ~shrlen:0 write fname x

  let stream_to_string ?(len = 1024) ?(lf = "\n") write stream =
    let ob = Bi_outbuf.create len in
    Stream.iter (fun x -> write ob x; Bi_outbuf.add_string ob lf) stream;
    Bi_outbuf.contents ob

  let stream_to_channel ?len ?(lf = "\n") write oc stream =
    let ob = Bi_outbuf.create_channel_writer ?len ~shrlen:0 oc in
    Stream.iter (fun x -> write ob x; Bi_outbuf.add_string ob lf) stream;
    Bi_outbuf.flush_channel_writer ob

  let stream_to_file ?len ?lf write fname stream =
    output_file fname (fun oc -> stream_to_channel ?len ?lf write oc stream)

  let list_to_string ?len ?lf write l =
    stream_to_string ?len ?lf write (Stream.of_list l)

  let list_to_channel ?len ?lf write oc l =
    stream_to_channel ?len ?lf write oc (Stream.of_list l)

  let list_to_file ?len ?lf write fname  l =
    stream_to_file ?len ?lf write fname (Stream.of_list l)

  let preset_unknown_field_handler loc name =
    let msg =
      Printf.sprintf
        "Found unknown JSON field %s while expecting type defined at: %s"
        name loc
    in
    failwith msg

  let unknown_field_handler = ref preset_unknown_field_handler
end

module Validation =
struct
  type path_elem = [ `Field of string | `Index of int ]
  type path = path_elem list

  let string_of_path l =
    String.concat "" (
      List.rev_map (
        function
          | `Field s -> "." ^ s
          | `Index n -> "[" ^ string_of_int n ^ "]"
      ) l
    )

  type error = {
    error_path : path;
    error_msg : string option;
  }

  let error ?msg path = {
    error_path = path;
    error_msg = msg;
  }

  let string_of_error x =
    let path = string_of_path x.error_path in
    match x.error_msg with
        None ->
          "Validation error; path = " ^ path
      | Some msg ->
          Printf.sprintf "Validation error: %s; path = %s" msg path
end
atd-2.1.0/atdgen-runtime/src/util.mli000066400000000000000000000356331357165332000174730ustar00rootroot00000000000000(** Various convenience types and functions meant for the user of atdgen. *)

type 'a ocaml_array = 'a array
    (** An alias for OCaml's standard array type,
        used in generated code. *)

module Biniou :
sig
  type 'a reader = Bi_inbuf.t -> 'a
    (** Type of a [read_] function as produced by [atdgen -biniou]. *)

  type 'a writer = Bi_outbuf.t -> 'a -> unit
    (** Type of a [write_] function as produced by [atdgen -biniou]. *)

  val from_channel :
    ?len:int ->
    ?shrlen:int ->
    'a reader -> in_channel -> 'a
    (** Read a biniou value from a channel.
        @param len     input buffer length.
        @param shrlen  obsolete and ignored.
    *)

  val from_file :
    ?len:int ->
    ?shrlen:int ->
    'a reader -> string -> 'a
    (** Read a biniou value from a file.
        @param len     input buffer length.
        @param shrlen  obsolete and ignored.
    *)

  val to_channel :
    ?len:int ->
    ?shrlen:int ->
    'a writer -> out_channel -> 'a -> unit
    (** Write a biniou value to a channel.
        @param len     output buffer length.
        @param shrlen  obsolete and ignored.
    *)

  val to_file :
    ?len:int ->
    ?shrlen:int ->
    'a writer -> string -> 'a -> unit
    (** Write a biniou value to a file.
        @param len     output buffer length.
        @param shrlen  obsolete and ignored.
    *)
end

module Json :
sig
  type 'a reader = Yojson.Safe.lexer_state -> Lexing.lexbuf -> 'a
    (** Type of a [read_] function as produced by [atdgen -json].

        In versions of yojson greater than 1.0.1,
        type [Yojson.Safe.lexer_state] is equivalent to
        [Yojson.lexer_state], [Yojson.Basic.lexer_state] and
        [Yojson.Raw.lexer_state]. *)

  type 'a writer = Bi_outbuf.t -> 'a -> unit
    (** Type of a [write_] function as produced by [atdgen -json]. *)

  val from_lexbuf :
    ?stream:bool ->
    'a reader -> Yojson.Safe.lexer_state -> Lexing.lexbuf -> 'a
    (** Read a JSON value from a lexbuf.
        @param stream  if [true], the JSON parser will not try
                       to consume whitespace until the end of file.
                       Default is [false], which raises a [Yojson.Json_error]
                       exception if the valid JSON value is followed
                       by anything other than standard JSON whitespace.
    *)

  val from_string :
    ?buf:Bi_outbuf.t ->
    ?fname:string ->
    ?lnum:int ->
    'a reader -> string -> 'a
    (** Convert a JSON value from a string.
        @param buf     buffer used to accumulate string data
                       during the lexing phase.
        @param fname   input file name to be used in error messages.
                       It does not have to be the name of a real file,
                       it can be something like [""].
        @param lnum    line number to assign to the first line of input.
                       For example [lnum=10] means that an error on the first
                       line of input will be reported as an error on line 10.
                       Default: 1.
    *)

  val from_channel :
    ?buf:Bi_outbuf.t ->
    ?fname:string ->
    ?lnum:int ->
    'a reader -> in_channel -> 'a
    (** Read a JSON value from a channel.
        @param buf     buffer used to accumulate string data
                       during the lexing phase.
        @param fname   input file name to be used in error messages.
                       It does not have to be the name of a real file,
                       it can be something like [""].
        @param lnum    line number to assign to the first line of input.
                       For example [lnum=10] means that an error on the first
                       line of input will be reported as an error on line 10.
                       Default: 1.
    *)

  val from_file :
    ?buf:Bi_outbuf.t ->
    ?fname:string ->
    ?lnum:int ->
    'a reader -> string -> 'a
    (** Read a JSON value from a channel.
        @param buf     buffer used to accumulate string data
                       during the lexing phase.
        @param fname   input file name to be used in error messages.
                       It is intended to represent the source file
                       if it is different from the input file.
        @param lnum    line number to assign to the first line of input.
                       For example [lnum=10] means that an error on the first
                       line of input will be reported as an error on line 10.
                       Default: 1.
    *)

  val stream_from_lexbuf :
    ?fin:(unit -> unit) ->
    'a reader -> Yojson.Safe.lexer_state -> Lexing.lexbuf -> 'a Stream.t
    (** Read a stream of JSON values from a lexbuf.
        @param fin     finalization function executed once when the end of the
                       stream is reached either because there is no more
                       input or because of an exception. This is typically
                       used to close the input channel, e.g.
                       [fun () -> close_in_noerr ic].
    *)

  val stream_from_string :
    ?buf:Bi_outbuf.t ->
    ?fin:(unit -> unit) ->
    ?fname:string ->
    ?lnum:int ->
    'a reader -> string -> 'a Stream.t
    (** Read a stream of JSON values from a channel.
        Values do not have to be separated by newline characters.
        @param buf     buffer used to accumulate string data
                       during the lexing phase.
        @param fin     finalization function executed once when the end of the
                       stream is reached either because there is no more
                       input or because of an exception. This is typically
                       used to free the underlying resources, if any.
        @param fname   input file name to be used in error messages.
                       It does not have to be the name of a real file,
                       it can be something like [""].
        @param lnum    line number to assign to the first line of input.
                       For example [lnum=10] means that an error on the first
                       line of input will be reported as an error on line 10.
                       Default: 1.
    *)

  val stream_from_channel :
    ?buf:Bi_outbuf.t ->
    ?fin:(unit -> unit) ->
    ?fname:string ->
    ?lnum:int ->
    'a reader -> in_channel -> 'a Stream.t
    (** Read a stream of JSON values from a channel.
        Values do not have to be separated by newline characters.
        @param buf     buffer used to accumulate string data
                       during the lexing phase.
        @param fin     finalization function executed once when the end of the
                       stream is reached either because there is no more
                       input or because of an exception. This is typically
                       used to close the input channel, e.g.
                       [fun () -> close_in_noerr ic].
        @param fname   input file name to be used in error messages.
                       It does not have to be the name of a real file,
                       it can be something like [""].
        @param lnum    line number to assign to the first line of input.
                       For example [lnum=10] means that an error on the first
                       line of input will be reported as an error on line 10.
                       Default: 1.
    *)

  val stream_from_file :
    ?buf:Bi_outbuf.t ->
    ?fin:(unit -> unit) ->
    ?fname:string ->
    ?lnum:int ->
    'a reader -> string -> 'a Stream.t
    (** Read a stream of JSON values from a file.
        Values do not have to be separated by newline characters.
        @param buf     buffer used to accumulate string data
                       during the lexing phase.
        @param fin     finalization function executed once when the end of the
                       stream is reached either because there is no more
                       input or because of an exception. This can be used
                       to remove the input file if it was temporary, e.g.
                       [fun () -> Sys.remove fname].
        @param fname   input file name to be used in error messages.
                       It is intended to represent the source file
                       if it is different from the input file.
        @param lnum    line number to assign to the first line of input.
                       For example [lnum=10] means that an error on the first
                       line of input will be reported as an error on line 10.
                       Default: 1.
    *)

  val list_from_string :
    ?buf:Bi_outbuf.t ->
    ?fin:(unit -> unit) ->
    ?fname:string ->
    ?lnum:int ->
    'a reader -> string -> 'a list
    (** Read a list of JSON values from a channel.
        Values do not have to be separated by newline characters.
        @param buf     buffer used to accumulate string data
                       during the lexing phase.
        @param fin     finalization function executed once when the end of the
                       stream is reached either because there is no more
                       input or because of an exception. This is typically
                       used to free the underlying resources, if any.
        @param fname   input file name to be used in error messages.
                       It does not have to be the name of a real file,
                       it can be something like [""].
        @param lnum    line number to assign to the first line of input.
                       For example [lnum=10] means that an error on the first
                       line of input will be reported as an error on line 10.
                       Default: 1.
    *)

  val list_from_channel :
    ?buf:Bi_outbuf.t ->
    ?fin:(unit -> unit) ->
    ?fname:string ->
    ?lnum:int ->
    'a reader -> in_channel -> 'a list
    (** Read a list of JSON values from a channel.
        Values do not have to be separated by newline characters.
        @param buf     buffer used to accumulate string data
                       during the lexing phase.
        @param fin     finalization function executed once when the end of the
                       stream is reached either because there is no more
                       input or because of an exception. This is typically
                       used to close the input channel, e.g.
                       [fun () -> close_in_noerr ic].
        @param fname   input file name to be used in error messages.
                       It does not have to be the name of a real file,
                       it can be something like [""].
        @param lnum    line number to assign to the first line of input.
                       For example [lnum=10] means that an error on the first
                       line of input will be reported as an error on line 10.
                       Default: 1.
    *)

  val list_from_file :
    ?buf:Bi_outbuf.t ->
    ?fname:string ->
    ?lnum:int ->
    'a reader -> string -> 'a list
     (** Read a list of JSON values from a file.
        Values do not have to be separated by newline characters.
        @param buf     buffer used to accumulate string data
                       during the lexing phase.
        @param fname   input file name to be used in error messages.
                       It is intended to represent the source file
                       if it is different from the input file.
        @param lnum    line number to assign to the first line of input.
                       For example [lnum=10] means that an error on the first
                       line of input will be reported as an error on line 10.
                       Default: 1.
    *)

  val to_string :
    ?len:int ->
    'a writer -> 'a -> string
    (** Write a JSON value to a string.
        @param len     output buffer length.
    *)

  val to_channel :
    ?len:int ->
    'a writer -> out_channel -> 'a -> unit
    (** Write a JSON value to a channel.
        @param len     output buffer length.
    *)

  val to_file :
    ?len:int ->
    'a writer -> string -> 'a -> unit
    (** Write a JSON value to a file.
        @param len     output buffer length.
    *)

  val stream_to_string :
    ?len:int ->
    ?lf:string ->
    'a writer -> 'a Stream.t -> string
    (** Write a stream of values to a string.
        @param len     output buffer length.
        @param lf      additional element terminator. Default: ["\n"].
    *)

  val stream_to_channel :
    ?len:int ->
    ?lf:string ->
    'a writer -> out_channel -> 'a Stream.t -> unit
    (** Write a stream of values to a channel.
        @param len     output buffer length.
        @param lf      additional element terminator. Default: ["\n"].
    *)

  val stream_to_file :
    ?len:int ->
    ?lf:string ->
    'a writer -> string -> 'a Stream.t -> unit
    (** Write a stream of values to a file.
        @param len     output buffer length.
        @param lf      additional element terminator. Default: ["\n"].
    *)

  val list_to_string :
    ?len:int ->
    ?lf:string ->
    'a writer -> 'a list -> string
    (** Write a list of values to a string.
        @param len     output buffer length.
        @param lf      additional element terminator. Default: ["\n"].
    *)

  val list_to_channel :
    ?len:int ->
    ?lf:string ->
    'a writer -> out_channel -> 'a list -> unit
    (** Write a list of values to a channel.
        @param len     output buffer length.
        @param lf      additional element terminator. Default: ["\n"].
    *)

  val list_to_file :
    ?len:int ->
    ?lf:string ->
    'a writer -> string -> 'a list -> unit
    (** Write a list of values to a file.
        @param len     output buffer length.
        @param lf      additional element terminator. Default: ["\n"].
    *)


  val preset_unknown_field_handler : string -> string -> unit
    (**
        [preset_unknown_field_handler src_loc field_name]
        raises a [Failure] exception with a message containing
        the location of the type definition in the source ATD file
        ([src_loc]) and the name of the field ([field_name]).
    *)

  val unknown_field_handler : (string -> string -> unit) ref
    (** Function called when an unknown JSON field is encountered if
        the code was generated by atdgen -json-strict-fields.
        Its preset behavior is to call [preset_unknown_field_handler]
        which raises a [Failure] exception.

        Usage: [!Atdgen_runtime.Util.Json.unknown_field_handler src_loc field_name]
        where [src_loc] is the location of the type definition
        in the source ATD file and [field_name] is the unknown
        JSON field name.
    *)
end

module Validation :
sig
  type path_elem = [ `Field of string | `Index of int ]
  type path = path_elem list
    (** Path within a value, used to report validation errors. *)

  val string_of_path : path -> string
    (** Reverse and concatenate a path into a string
        such as [".settings.ports[0]"] *)

  type error = {
    error_path : path;
    error_msg : string option;
  }

  val error : ?msg: string -> path -> error
  val string_of_error : error -> string
end
atd-2.1.0/atdgen-runtime/src/version.ml000066400000000000000000000002161357165332000200170ustar00rootroot00000000000000(** The version of the atdgen-runtime library. *)

(* The value found in CHANGES.md is injected here by topkg. *)
let version = "%%VERSION%%"
atd-2.1.0/atdgen.opam000066400000000000000000000034131357165332000144100ustar00rootroot00000000000000# This file is generated by dune, edit dune-project instead
opam-version: "2.0"
synopsis:
  "Generates efficient JSON serializers, deserializers and validators"
description: """
Atdgen is a command-line program that takes as input type definitions in the ATD
syntax and produces OCaml code suitable for data serialization and
deserialization.
Two data formats are currently supported, these are biniou and JSON.
Atdgen-biniou and Atdgen-json will refer to Atdgen used in one context or the
other.
Atdgen was designed with efficiency and durability in mind. Software authors are
encouraged to use Atdgen directly and to write tools that may reuse part of
Atdgen’s source code."""
maintainer: ["Rudi Grinberg "]
authors: [
  "Martin Jambon "
  "David Sheets "
  "Rudi Grinberg "
  "Ivan Jager "
  "Jeff Meister "
  "Carmelo Piccione "
  "Raman Varabets "
  "Mathieu Baudet "
  "Rauan Mayemir "
  "Louis Roché "
  "Brendan Long "
  "Christophe Troestler "
  "Vincent Bernardoff "
  "haoyang "
]
license: "MIT"
homepage: "https://github.com/ahrefs/atd"
bug-reports: "https://github.com/ahrefs/atd/issues"
depends: [
  "ocaml" {>= "4.02"}
  "dune" {>= "1.11"}
  "atd" {>= "2.0.0"}
  "atdgen-runtime" {>= "2.0.0"}
  "biniou" {>= "1.0.6"}
  "yojson" {>= "1.7.0"}
]
build: [
  ["dune" "subst"] {pinned}
  [
    "dune"
    "build"
    "-p"
    name
    "-j"
    jobs
    "@install"
    "@runtest" {with-test}
    "@doc" {with-doc}
  ]
]
dev-repo: "git+https://github.com/ahrefs/atd.git"
atd-2.1.0/atdgen/000077500000000000000000000000001357165332000135315ustar00rootroot00000000000000atd-2.1.0/atdgen/INSTALL000066400000000000000000000041231357165332000145620ustar00rootroot00000000000000
                   Installation instructions for atdgen
                   ====================================


Godi makes the installation process straightforward. Simply install the
godi-atdgen package using `godi_console'. Dependencies will be selected
and installed automatically.


Requirements
------------

- Objective Caml (>= 3.11 is fine, earlier versions are probably fine too)

- GNU make

- Findlib (`ocamlfind' command):
    http://www.camlcity.org/archive/programming/findlib.html

- menhir (installation of atd):
    http://pauillac.inria.fr/~fpottier/menhir/

- easy-format (required for biniou, yojson and atd):
    http://martin.jambon.free.fr/easy-format.html

- cppo (installation of yojson only):
    http://martin.jambon.free.fr/cppo.html

- biniou (>= 1.0.0):
    http://martin.jambon.free.fr/biniou.html

- yojson (>= 1.0.0):
    http://martin.jambon.free.fr/yojson.html

- atd (>= 1.0.0):
    http://oss.wink.com/atd/


Manual installation
-------------------

make           # or `make all' for the bytecode-only version

make install   # or `make BINDIR=/foo/bin install' for installing executables
               # in a place other than the guessed default.


Manual uninstallation
---------------------

make uninstall



Getting started
---------------

First take a look at the example in the `example' subdirectory.

Commands installed by the different packages:

- atdgen: produces OCaml code from ATD type definitions
- atdcat: pretty-prints ATD type definitions
- bdump: displays biniou data in human-readable form
- ydump: pretty-prints JSON data

Sources of documentation:

- command-line interface help: `atdgen -help'
- type definition syntax: atd manual
- options available for each language (ocaml, biniou, json, doc): atdgen manual
- generic biniou tree: biniou documentation, module Bi_io
- generic JSON tree: yojson documentation, module Yojson.Safe
- biniou input buffers: biniou documentation, module Bi_inbuf
- output buffers: biniou documentation, module Bi_outbuf


Contact
-------
Bugs and feedback should be sent to Martin Jambon 
or .
atd-2.1.0/atdgen/README.md000066400000000000000000000006031357165332000150070ustar00rootroot00000000000000Atdgen uses type definitions in the ATD syntax and generates
efficient [JSON](http://json.org) serializers, deserializers and
validators for OCaml.

Installation
------------

```
$ opam install atdgen
```

Documentation
-------------

https://mjambon.github.io/atdgen-doc/


How to contribute
-----------------

See https://github.com/mjambon/documents/blob/master/how-to-contribute.md
atd-2.1.0/atdgen/TODO.md000066400000000000000000000020341357165332000146170ustar00rootroot00000000000000* Support JSON object syntax for variants, e.g.:
  type t = A | B of int
  Currently supported: "A"
                       ["B", 123]
                       <"A">
                       <"B":123>
  To do: {"A": null}
         {"B": 123}

* Find a good way to support variants represented as records whose type is
  given by one of their fields.

* Plans for atdgen 2:
  - create one (sub)command for each target language
    (atdgen-ocaml, atdgen-java, atdgen-atd, atdgen-ts)
  - imply -std-json, i.e. do not produce code that produces JSON
    in the extended syntax for variants (<"A">, <"B":123>)
    or tuples (("a", 123, {"x":0}))
  - make it possible to produce all outputs in one call to atdgen.
    "atdgen foo -m tjv" would read file "foo.atd" and produce
     files foo_{t|j|v}.{ml|mli}
  - use classic variants instead of polymorphic variants by default
    since ocaml >= 4.01 makes them easier to use

* Support for other languages:
  - merge atdj (JSON serializers for Java) into atdgen
  - translate ATD into TypeScript type definitions
atd-2.1.0/atdgen/atd.descr000066400000000000000000000004521357165332000153240ustar00rootroot00000000000000Parser for the ATD data format description language

ATD is the OCaml library providing a parser for the ATD language and various
utilities. ATD stands for Adjustable Type Definitions in reference to its main
property of supporting annotations that allow a good fit with a variety of data
formats.
atd-2.1.0/atdgen/atdgen-runtime.descr000066400000000000000000000001671357165332000175020ustar00rootroot00000000000000Runtime for code generated by atdgen

Code generated by the atdgen binary should copmile and link against this
library.atd-2.1.0/atdgen/atdgen.descr000066400000000000000000000010701357165332000160130ustar00rootroot00000000000000Generates efficient JSON serializers, deserializers and validators

Atdgen is a command-line program that takes as input type definitions in the ATD
syntax and produces OCaml code suitable for data serialization and
deserialization. Two data formats are currently supported, these are biniou and
JSON. Atdgen-biniou and Atdgen-json will refer to Atdgen used in one context or
the other. Atdgen was designed with efficiency and durability in mind. Software
authors are encouraged to use Atdgen directly and to write tools that may reuse
part of Atdgen’s source code.
atd-2.1.0/atdgen/atdj.descr000066400000000000000000000001451357165332000154750ustar00rootroot00000000000000Java generator for atd files

Generates java serializers and deserializers from atd type definitions.atd-2.1.0/atdgen/bin/000077500000000000000000000000001357165332000143015ustar00rootroot00000000000000atd-2.1.0/atdgen/bin/ag_main.ml000066400000000000000000000320351357165332000162310ustar00rootroot00000000000000open Atd.Import
open Atdgen_emit

let append l1 l2 =
  List.concat_map (fun s1 -> List.map (fun s2 -> s1 ^ s2) l2) l1

let get_file_list base =
  append (append [base] ["_t";"_b";"_j";"_v"]) [".mli";".ml"]

let print_file_list base =
  let l = get_file_list base in
  print_endline (String.concat " " l)

let print_deps base =
  let l = get_file_list base in
  List.iter (fun out -> printf "%s: %s.atd\n" out base) l;
  flush stdout

let set_once varname var x =
  match !var with
      Some y ->
        if x <> y then
          failwith (sprintf "\
Command-line parameter %S is set multiple times
to incompatible values."
                      varname)

    | None ->
        var := Some x

type mode =
  | T (* -t (type defs and create_* functions) *)
  | B (* -b (biniou serialization) *)
  | J (* -j (json serialization) *)
  | V (* -v (validators) *)
  | Dep (* -dep (print all file dependencies produced by -t -b -j -v) *)
  | List (* -list (list all files produced by -t -b -j -v) *)

  | Biniou (* -biniou (deprecated) *)
  | Json (* -json (deprecated) *)
  | Validate (* -validate (deprecated) *)
  | Bucklescript (* -bs (bucklescript) *)

let parse_ocaml_version () =
  let re = Re.Str.regexp "^\\([0-9]+\\)\\.\\([0-9]+\\)" in
  if Re.Str.string_match re Sys.ocaml_version 0 then
    let major = Re.Str.matched_group 1 Sys.ocaml_version in
    let minor = Re.Str.matched_group 2 Sys.ocaml_version in
    Some (int_of_string major, int_of_string minor)
  else
    None

let main () =
  let pos_fname = ref None in
  let pos_lnum = ref None in
  let files = ref [] in
  let opens = ref [] in
  let with_typedefs = ref None in
  let with_create = ref None in
  let with_fundefs = ref None in
  let all_rec = ref false in
  let out_prefix = ref None in
  let mode = ref (None : mode option) in
  let std_json = ref false in
  let j_preprocess_input = ref None in
  let j_defaults = ref false in
  let unknown_field_handler = ref None in
  let type_aliases = ref None in
  let ocaml_version = parse_ocaml_version () in
  let set_opens s =
    let l = Re.Str.split (Re.Str.regexp " *, *\\| +") s in
    opens := List.rev_append l !opens
  in
  let pp_convs : Ocaml.pp_convs ref = ref (Ocaml.Ppx []) in
  let options = [
    "-type-conv", Arg.String (fun s ->
      pp_convs := Camlp4 (Re.Str.split (Re.Str.regexp ",") s)),
    "
    GEN1,GEN2,...
         Insert 'with GEN1, GEN2, ...' after OCaml type definitions for the
         type-conv preprocessor
    ";
    "-deriving-conv", Arg.String (fun s ->
      pp_convs := Ocaml.Ppx (Re.Str.split (Re.Str.regexp ",") s)),
    "
    GEN1,GEN2,...
         Insert 'with GEN1, GEN2, ...' after OCaml type definitions for the
         ppx_deriving preprocessor
    ";
    "-t", Arg.Unit (fun () ->
                      set_once "output type" mode T;
                      set_once "no function definitions" with_fundefs false),
    "
          Produce files example_t.mli and example_t.ml
          containing OCaml type definitions derived from example.atd.";

    "-b", Arg.Unit (fun () -> set_once "output type" mode B),
    "
          Produce files example_b.mli and example_b.ml
          containing OCaml serializers and deserializers for the Biniou
          data format from the specifications in example.atd.";

    "-j", Arg.Unit (fun () -> set_once "output type" mode J),
    "
          Produce files example_j.mli and example_j.ml
          containing OCaml serializers and deserializers for the JSON
          data format from the specifications in example.atd.";

    "-bs", Arg.Unit (fun () -> set_once "output type" mode Bucklescript),
    "
          Produce files example_bs.mli and example_bs.ml
          containing OCaml serializers and deserializers for the JSON
          data format from the specifications in example.atd using
          bucklescript's json api.";


    "-v", Arg.Unit (fun () -> set_once "output type" mode V),
    "
          Produce files example_v.mli and example_v.ml
          containing OCaml functions for creating records and
          validators from the specifications in example.atd.";

    "-dep", Arg.Unit (fun () -> set_once "output type" mode Dep),
    "
          Output Make-compatible dependencies for all possible
          products of atdgen -t, -b, -j and -v, and exit.";

    "-list", Arg.Unit (fun () -> set_once "output type" mode List),
    "
          Output a space-separated list of all possible products of
          atdgen -t, -b, -j and -v, and exit.";

    "-o", Arg.String (fun s ->
                        let out =
                          match s with
                              "-" -> Ox_emit.Stdout
                            | s -> Ox_emit.Files s
                        in
                        set_once "output prefix" out_prefix out),
    "[ PREFIX | - ]
          Use this prefix for the generated files, e.g. 'foo/bar' for
          foo/bar.ml and foo/bar.mli.
          `-' designates stdout and produces code of the form
            struct ... end : sig ... end";

    "-biniou",
    Arg.Unit (fun () ->
                set_once "output type" mode Biniou),
    "
          [deprecated in favor of -t and -b]
          Produce serializers and deserializers for Biniou
          including OCaml type definitions (default).";

    "-json",
    Arg.Unit (fun () ->
                set_once "output type" mode Json),
    "
          [deprecated in favor of -t and -j]
          Produce serializers and deserializers for JSON
          including OCaml type definitions.";

    "-j-std",
    Arg.Unit (fun () ->
                std_json := true),
    "
          Convert tuples and variants into standard JSON and
          refuse to print NaN and infinities (implying -json mode
          unless another mode is specified).";

    "-std-json",
    Arg.Unit (fun () ->
                std_json := true),
    "
          [deprecated in favor of -j-std]
          Same as -j-std.";

    "-j-pp",
    Arg.String (fun s -> set_once "-j-pp" j_preprocess_input s),
    "
          OCaml function of type (string -> string) applied on the input
          of each *_of_string function generated by atdgen (JSON mode).
          This is originally intended for UTF-8 validation of the input
          which is not performed by atdgen.";

    "-j-defaults",
    Arg.Set j_defaults,
    "
          Output JSON record fields even if their value is known
          to be the default.";

    "-j-strict-fields",
    Arg.Unit (
      fun () ->
        set_once "unknown field handler" unknown_field_handler
          "!Atdgen_runtime.Util.Json.unknown_field_handler"
    ),
    "
          Call !Atdgen_runtime.Util.Json.unknown_field_handler for every unknown JSON field
          found in the input instead of simply skipping them.
          The initial behavior is to raise an exception.";

    "-j-custom-fields",
    Arg.String (
      fun s ->
        set_once "unknown field handler" unknown_field_handler s
    ),
    "FUNCTION
          Call the given function of type (string -> unit)
          for every unknown JSON field found in the input
          instead of simply skipping them.
          See also -j-strict-fields.";

    "-validate",
    Arg.Unit (fun () ->
                set_once "output type" mode Validate),
    "
          [deprecated in favor of -t and -v]
          Produce data validators from  annotations
          where x is a user-written validator to be applied on a specific
          node.
          This is typically used in conjunction with -extend because
          user-written validators depend on the type definitions.";

    "-extend", Arg.String (fun s -> type_aliases := Some s),
    "MODULE
          Assume that all type definitions are provided by the specified
          module unless otherwise annotated. Type aliases are created
          for each type, e.g.
            type t = Module.t";

    "-open", Arg.String set_opens,
    "MODULE1,MODULE2,...
          List of modules to open (comma-separated or space-separated)";

    "-nfd", Arg.Unit (fun () ->
                        set_once "no function definitions" with_fundefs false),
    "
          Do not dump OCaml function definitions";

    "-ntd", Arg.Unit (fun () ->
                        set_once "no type definitions" with_typedefs false),
    "
          Do not dump OCaml type definitions";

    "-pos-fname", Arg.String (set_once "pos-fname" pos_fname),
    "FILENAME
          Source file name to use for error messages
          (default: input file name)";

    "-pos-lnum", Arg.Int (set_once "pos-lnum" pos_lnum),
    "LINENUM
          Source line number of the first line of the input (default: 1)";

    "-rec", Arg.Set all_rec,
    "
          Keep OCaml type definitions mutually recursive";
    "-version",
    Arg.Unit (fun () ->
                print_endline Version.version;
                exit 0),
    "
          Print the version identifier of atdgen and exit.";
  ]
  in
  let msg = sprintf "\
Generate OCaml code offering:
  * OCaml type definitions translated from ATD file (-t)
  * serializers and deserializers for Biniou (-b)
  * serializers and deserializers for JSON (-j)
  * record-creating functions supporting default fields (-v)
  * user-specified data validators (-v)

Recommended usage: %s (-t|-b|-j|-v|-dep|-list|-bs) example.atd" Sys.argv.(0) in
  Arg.parse options (fun file -> files := file :: !files) msg;

  if (!std_json
      || !unknown_field_handler <> None) && !mode = None then
    set_once "output mode" mode Json;

  let mode =
    match !mode with
        None -> Biniou
      | Some x -> x
  in

  let with_create =
    match !with_create with
        Some x -> x
      | None ->
          match mode with
              T | B | J | Bucklescript -> false
            | V -> true
            | Biniou | Json | Validate -> true
            | Dep | List -> true (* don't care *)
  in

  let force_defaults =
    match mode with
        J | Json -> !j_defaults
      | T
      | B | Biniou
      | V | Validate
      | Bucklescript
      | Dep | List -> false (* don't care *)
  in

  let atd_file =
    match !files with
        [s] -> Some s
      | [] -> None
      | _ ->
          Arg.usage options msg;
          exit 1
  in
  let base_ocaml_prefix =
    match !out_prefix, atd_file with
        Some x, _ -> x
      | None, Some file ->
          Ox_emit.Files (
              if Filename.check_suffix file ".atd" then
                Filename.chop_extension file
              else
                file
          )
      | None, None -> Stdout
  in
  let base_prefix, ocaml_prefix =
    match base_ocaml_prefix with
        Ox_emit.Stdout -> None, Ox_emit.Stdout
      | Files base ->
          Some base, Ox_emit.Files
            (match mode with
                 T -> base ^ "_t"
               | B -> base ^ "_b"
               | J -> base ^ "_j"
               | V -> base ^ "_v"
               | Bucklescript -> base ^ "_bs"
               | Dep
               | List
               | Biniou
               | Validate
               | Json -> base
            )
  in
  let type_aliases =
    match base_prefix with
        None ->
          (match mode with
               B | J |  V | Bucklescript -> Some "T"
           | Biniou | Validate
           | T | Dep | List
           | Json -> None
          )
      | Some base ->
          match !type_aliases with
              Some _ as x -> x
            | None ->
                (match mode with
                     B | J | V | Bucklescript ->
                       Some (String.capitalize_ascii (Filename.basename base) ^ "_t")
                 | T | Json | Dep | List | Validate
                   | Biniou -> None
          )
  in
  let get_base_prefix () =
    match base_prefix with
        None -> failwith "Undefined output file names"
      | Some s -> s
  in
  match mode with
      Dep -> print_deps (get_base_prefix ())
    | List -> print_file_list (get_base_prefix ())
    | Bucklescript
    | T | B | J | V | Biniou | Json | Validate ->

        let opens = List.rev !opens in
        let make_ocaml_files =
          match mode with
              T ->
                Ob_emit.make_ocaml_files
            | B | Biniou ->
                Ob_emit.make_ocaml_files
            | J | Json ->
                Oj_emit.make_ocaml_files
                  ~std: !std_json
                  ~unknown_field_handler: !unknown_field_handler
                  ~preprocess_input: !j_preprocess_input
            | V | Validate ->
                Ov_emit.make_ocaml_files
            | Bucklescript ->
                Obuckle_emit.make_ocaml_files
            | Dep | List -> assert false
        in
        let with_default default = function None -> default | Some x -> x in

        make_ocaml_files
          ~pp_convs: !pp_convs
          ~opens
          ~with_typedefs: (with_default true !with_typedefs)
          ~with_create
          ~with_fundefs: (with_default true !with_fundefs)
          ~all_rec: !all_rec
          ~pos_fname: !pos_fname
          ~pos_lnum: !pos_lnum
          ~type_aliases
          ~force_defaults
          ~ocaml_version
          atd_file ocaml_prefix

let () =
  try main ()
  with
      Atd.Ast.Atd_error s
    | Failure s ->
        flush stdout;
        eprintf "%s\n%!" s;
        exit 1
    | e -> raise e
atd-2.1.0/atdgen/bin/dune000066400000000000000000000001501357165332000151530ustar00rootroot00000000000000(executables
 (libraries re atd atdgen_emit)
 (names ag_main)
 (public_names atdgen)
 (package atdgen))
atd-2.1.0/atdgen/example/000077500000000000000000000000001357165332000151645ustar00rootroot00000000000000atd-2.1.0/atdgen/example/Makefile000066400000000000000000000003321357165332000166220ustar00rootroot00000000000000.PHONY: default
default:
	./example.sh

.PHONY: clean
	rm -f *.cm[iox] *.o *.annot \
		format_v[12].mli format_v[12].ml \
		upgrade_demo upgrade_demo.exe \
		old_sample.dat new_sample.dat \
		old_data.dat new_data.dat
atd-2.1.0/atdgen/example/README000066400000000000000000000012451357165332000160460ustar00rootroot00000000000000
                         Example using atdgen
                         ====================


This simple but standalone example illustrates the use of atdgen to
manage a backward-compatible change of data format.

The old data format is defined in `format_v1.atd'.  The newer data
format is defined in `format_v2.atd'.  It is a record type from which
one field was removed and another field was added.

The program `upgrade_demo' demonstrates the use of atdgen in general
and how to make a data format evolve without losing compatibility
with legacy data files or services.

1.  Atdgen must be installed properly
2.  Run `make'
3.  Inspect the files starting with example.sh
atd-2.1.0/atdgen/example/example.sh000066400000000000000000000023031357165332000171510ustar00rootroot00000000000000#! /bin/sh

echo "Running script $0, look inside for comments."

# Exit on error
set -e

# Produce format_v1.mli and format_v1.ml from type definition
atdgen format_v1.atd

# Produce format_v2.mli and format_v2.ml from type definition
atdgen format_v2.atd

# Compile and link all OCaml code, producing upgrade_demo
ocamlfind ocamlopt -g -dtypes -package atdgen -linkpkg \
  format_v1.mli format_v1.ml \
  format_v2.mli format_v2.ml \
  upgrade_demo.ml -o upgrade_demo

# Save biniou sample in the old format
./upgrade_demo old > old_sample.dat

# Save the same data after conversion to the new format
./upgrade_demo new > new_sample.dat

# Use our sample data in the old format for the next test
cp old_sample.dat old_data.dat

# Read data in the old format with code assuming the new format
./upgrade_demo up < old_data.dat > new_data.dat

# Dump a text representation of old and new data.
# The -w option specifies a list of candidate field names required for
# converting hashed field names into the original names.
echo "Data in format v1:"
bdump old_data.dat -w a,b,c,d
echo "Converted to format v2:"
bdump new_data.dat -w a,c,d,e
echo "Same, displayed using incomplete name dictionary:"
bdump new_data.dat -w a,b
atd-2.1.0/atdgen/example/format_v1.atd000066400000000000000000000001741357165332000175560ustar00rootroot00000000000000(* Older version of an imagined data format *)

type t = {
  a : int option;
  b : bool;
  ?c : int option;
  ~d : float;
}
atd-2.1.0/atdgen/example/format_v2.atd000066400000000000000000000005531357165332000175600ustar00rootroot00000000000000(* Newer version of an imagined data format. Compare to `format_v1.atd'. *)

type t = {
  a : int option;
  (* removed field b, making newer data unreadable with older software since
     b was not optional. *)
  ?c : int option;
  ~d : float;
  ~e : string list; (* added optional field e, allowing newer software
                       to read older data. *)
}
atd-2.1.0/atdgen/example/upgrade_demo.ml000066400000000000000000000024021357165332000201470ustar00rootroot00000000000000open Printf

let old_data = {
  Format_v1.a = Some 1;
  b = true;
  c = Some 3;
  d = 4.0;
}

let print_old_data () =
  let ob = Bi_outbuf.create_channel_writer stdout in
  Format_v1.write_t ob old_data;
  Bi_outbuf.flush_channel_writer ob;
  flush stdout

let convert x =
  Format_v2.t_of_string (Format_v1.string_of_t ~len:100 x)

let print_new_data () =
  let new_data = convert old_data in
  let ob = Bi_outbuf.create_channel_writer stdout in
  Format_v2.write_t ob new_data;
  Bi_outbuf.flush_channel_writer ob;
  flush stdout

let upgrade () =
  let ib = Bi_inbuf.from_channel stdin in
  let x = Format_v2.read_t ib in
  let ob = Bi_outbuf.create_channel_writer stdout in
  Format_v2.write_t ob x;
  Bi_outbuf.flush_channel_writer ob;
  flush stdout


let usage () =
  eprintf "\
Usage: %s [old|new|up]

old    print sample data in the old format
new    print sample data in the new format
up     read data in the new format from stdin and print data in the new format
%!"
    Sys.argv.(0);
  exit 1

let main () =
  match Sys.argv with
      [| _; action |] ->
        (match action with
             "old" -> print_old_data ()
           | "new" -> print_new_data ()
           | "up" -> upgrade ()
           | _ -> usage ()
        )
    | _ -> usage ()

let () = main ()
atd-2.1.0/atdgen/src/000077500000000000000000000000001357165332000143205ustar00rootroot00000000000000atd-2.1.0/atdgen/src/.gitignore000066400000000000000000000006751357165332000163200ustar00rootroot00000000000000META
VERSION
ag_version.ml
test.ml
test.mli
test2.ml
test2.mli
test2j.ml
test2j.mli
test3b.ml
test3b.mli
test3j.ml
test3j.mli
test4.ml
test4.mli
test4j.ml
test4j.mli
test5_b.ml
test5_b.mli
test5_j.ml
test5_j.mli
test5_t.ml
test5_t.mli
testj.ml
testj.mli
testjstd.ml
testjstd.mli
testv.ml
testv.mli
test-2.bin
test-2.json
test-json-files.json
test-json-streams.json
test-std.json
test.bin
test.json
test_atdgen
testdoc
ag_doc_lexer.ml
atdgen
dep
atd-2.1.0/atdgen/src/biniou.ml000066400000000000000000000027341357165332000161450ustar00rootroot00000000000000(*
  Mapping from ATD to biniou
*)

type biniou_int =
    [ `Svint | `Uvint | `Int8 | `Int16 | `Int32 | `Int64 ]

type biniou_float = [ `Float32 | `Float64 ]

type biniou_list = [ `Array | `Table ]

type biniou_field = { biniou_unwrapped : bool }

type biniou_repr =
  | Unit
  | Bool
  | Int of biniou_int
  | Float of biniou_float

  | String
  | Sum
  | Record
  | Tuple
  | List of biniou_list
  | Option
  | Nullable
  | Wrap
  | External

  | Cell
  | Field of biniou_field
  | Variant
  | Def

let biniou_int_of_string s : biniou_int option =
  match s with
      "svint" -> Some `Svint
    | "uvint" -> Some `Uvint
    | "int8" -> Some `Int8
    | "int16" -> Some `Int16
    | "int32" -> Some `Int32
    | "int64" -> Some `Int64
    | _ -> None

let biniou_float_of_string s : biniou_float option =
  match s with
      "float32" -> Some `Float32
    | "float64" -> Some `Float64
    | _ -> None

let biniou_list_of_string s : biniou_list option =
  match s with
      "array" -> Some `Array
    | "table" -> Some `Table
    | _ -> None

let get_biniou_int an =
  Atd.Annot.get_field
    ~parse:biniou_int_of_string
    ~default:`Svint
    ~sections:["biniou"]
    ~field:"repr"
    an

let get_biniou_float an =
  Atd.Annot.get_field
    ~parse:biniou_float_of_string
    ~default:`Float64
    ~sections:["biniou"]
    ~field:"repr"
    an

let get_biniou_list an =
  Atd.Annot.get_field
    ~parse:biniou_list_of_string
    ~default:`Array
    ~sections:["biniou"]
    ~field:"repr"
    an
atd-2.1.0/atdgen/src/biniou.mli000066400000000000000000000013521357165332000163110ustar00rootroot00000000000000(** Biniou-specific options derived from ATD annotations. *)

type biniou_int =
    [ `Svint | `Uvint | `Int8 | `Int16 | `Int32 | `Int64 ]

type biniou_float = [ `Float32 | `Float64 ]

type biniou_list = [ `Array | `Table ]

type biniou_field = { biniou_unwrapped : bool }

(** Biniou-specific options that decorate each kind of ATD AST node. *)
type biniou_repr =
  | Unit
  | Bool
  | Int of biniou_int
  | Float of biniou_float

  | String
  | Sum
  | Record
  | Tuple
  | List of biniou_list
  | Option
  | Nullable
  | Wrap
  | External

  | Cell
  | Field of biniou_field
  | Variant
  | Def

val get_biniou_float : Atd.Annot.t -> biniou_float
val get_biniou_int : Atd.Annot.t -> biniou_int
val get_biniou_list : Atd.Annot.t -> biniou_list
atd-2.1.0/atdgen/src/deprecated/000077500000000000000000000000001357165332000164205ustar00rootroot00000000000000atd-2.1.0/atdgen/src/deprecated/atdgen.ml000066400000000000000000000002151357165332000202120ustar00rootroot00000000000000[@@@deprecated "The runtime for Atdgen is now the module Atdgen_runtime existing
in the atdgen-runtime opam package"]
include Atdgen_runtime
atd-2.1.0/atdgen/src/deprecated/dune000066400000000000000000000003061357165332000172750ustar00rootroot00000000000000;; this is a deprecated library whose only purpose is to re-export the runtime
;; new users should be using atdgen_runtime
(library
 (name atdgen)
 (public_name atdgen)
 (libraries atdgen-runtime))
atd-2.1.0/atdgen/src/deprecated/version.ml000066400000000000000000000000341357165332000204340ustar00rootroot00000000000000let version = "%%VERSION%%"
atd-2.1.0/atdgen/src/doc_lexer.mli000066400000000000000000000004231357165332000167660ustar00rootroot00000000000000(** Parser for the contents of [] annotations. *)

type inline_element = [
  | `Text of string
  | `Code of string
]

type block = [
  | `Paragraph of inline_element list
  | `Pre of string
]

type document = block list

val parse_string : string -> document
atd-2.1.0/atdgen/src/doc_lexer.mll000066400000000000000000000065721357165332000170040ustar00rootroot00000000000000{
  type inline_element = [
    | `Text of string
    | `Code of string
  ]

  type block = [
    | `Paragraph of inline_element list
    | `Pre of string
  ]

  type document = block list

  let close_paragraph a1 a2 a3 =
    let a2 =
      match String.concat "" (List.rev a3) with
          "" -> a2
        | s -> `Text s :: a2
    in
    match List.rev a2 with
        [] -> a1
      | l -> `Paragraph l :: a1
}

let space = [' ' '\t' '\r' '\n']
let space' = space#['\n']

let par_special = ['\\' '{' '}']
let par_not_special = [^ '\\' '{' '}' ' ' '\t' '\r' '\n']
let verb_not_special = [^ '\\' ' ' '\t' '\r' '\n' '}']


(*
  Paragraph mode
*)
rule paragraph a1 a2 a3 = parse
    '\\' ('\\' | "{{" | "{{{" as s)
                        { paragraph a1 a2 (s :: a3) lexbuf }
  | "{{"
                        { let code = inline_verbatim [] lexbuf in
                          let a2 =
                            match String.concat "" (List.rev a3) with
                                "" -> a2
                              | s -> `Text s :: a2
                          in
                          let a2 = `Code code :: a2 in
                          paragraph a1 a2 [] lexbuf
                        }
  | space* "{{{" (("\r"?) "\n")?
                        { let pre = verbatim [] lexbuf in
                          let a1 = close_paragraph a1 a2 a3 in
                          let a1 = `Pre pre :: a1 in
                          paragraph a1 [] [] lexbuf
                        }
  | par_not_special+ as s
                        { paragraph a1 a2 (s :: a3) lexbuf }
  | space'* "\n"? space'*
                        { paragraph a1 a2 (" " :: a3) lexbuf }
  | space'* "\n" (space'* "\n")+ space'*
                        { let a1 = close_paragraph a1 a2 a3 in
                          paragraph a1 [] [] lexbuf
                        }
  | space* eof          { let a1 = close_paragraph a1 a2 a3 in
                          List.rev a1 }

  | _ as c              { paragraph a1 a2 (String.make 1 c :: a3) lexbuf }



(*
  Inline verbatim mode:
  Only "}}" need to be escaped.
  Backslashes can be escaped but single backslashes are tolerated.
*)
and inline_verbatim accu = parse
    "\\\\"              { inline_verbatim ("\\" :: accu) lexbuf }
  | "\\}}"              { inline_verbatim ("}}" :: accu) lexbuf }
  | space+              { inline_verbatim (" " :: accu) lexbuf }
  | verb_not_special+ as s
                        { inline_verbatim (s :: accu) lexbuf }
  | _ as c              { inline_verbatim (String.make 1 c :: accu) lexbuf }

  | space* "}}"         { String.concat "" (List.rev accu) }

  | eof                 { failwith "Missing `}}'" }


(*
  Verbatim paragraph mode:
  Only "}}}" need to be escaped.
  Backslashes can be escaped but single backslashes are tolerated.
*)
and verbatim accu = parse
    "\\\\"              { verbatim ("\\" :: accu) lexbuf }
  | "\\}}}"             { verbatim ("}}}" :: accu) lexbuf }
  | '\t'                { verbatim ("        " :: accu) lexbuf }
  | "\r\n"              { verbatim ("\n" :: accu) lexbuf }
  | verb_not_special+ as s
                        { verbatim (s :: accu) lexbuf }
  | _ as c              { verbatim (String.make 1 c :: accu) lexbuf }

  | ('\r'? '\n')? "}}}" { String.concat "" (List.rev accu) }

  | eof                 { failwith "Missing `}}}'" }

{
  let parse_string s =
    let lexbuf = Lexing.from_string s in
    paragraph [] [] [] lexbuf
}
atd-2.1.0/atdgen/src/dune000066400000000000000000000001141357165332000151720ustar00rootroot00000000000000(ocamllex doc_lexer)

(library
 (name atdgen_emit)
 (libraries atd yojson))
atd-2.1.0/atdgen/src/error.ml000066400000000000000000000007701357165332000160070ustar00rootroot00000000000000
open Printf

let error loc msg =
  failwith (sprintf "%s:\n%s" (Atd.Ast.string_of_loc loc) msg)

let error2 loc1 msg1 loc2 msg2 =
  failwith (sprintf "%s:\n%s\n%s:\n%s"
              (Atd.Ast.string_of_loc loc1) msg1
              (Atd.Ast.string_of_loc loc2) msg2)

let error3 loc1 msg1 loc2 msg2 loc3 msg3 =
  failwith (sprintf "%s:\n%s\n%s:\n%s\n%s:\n%s"
              (Atd.Ast.string_of_loc loc1) msg1
              (Atd.Ast.string_of_loc loc2) msg2
              (Atd.Ast.string_of_loc loc3) msg3)
atd-2.1.0/atdgen/src/error.mli000066400000000000000000000004211357165332000161510ustar00rootroot00000000000000(** Error reporting for any tool that processes ATD ASTs. *)

val error : Atd.Ast.loc -> string -> 'a

val error2 : Atd.Ast.loc -> string -> Atd.Ast.loc -> string -> 'a

val error3
  : Atd.Ast.loc
  -> string
  -> Atd.Ast.loc
  -> string
  -> Atd.Ast.loc
  -> string -> 'a
atd-2.1.0/atdgen/src/indent.ml000066400000000000000000000023031357165332000161310ustar00rootroot00000000000000
(*
  Atd.Indent extended with annnotations allowing some postprocessing.
*)

type t =
  | Line of string
  | Block of t list
  | Inline of t list
  | Annot of string * t

let rec strip = function
  | Line _ as x -> x
  | Block l -> Block (List.map strip l)
  | Inline l -> Inline (List.map strip l)
  | Annot (_, x) -> strip x

let paren l =
  Inline
    [ Line "("
    ; l
    ; Line ")"
    ]

let rec concat t = function
  | [] -> []
  | [x] -> [x]
  | x::xs -> x::t::(concat t xs)

let to_buffer ?(offset = 0) ?(indent = 2) buf l =
  let rec print n = function
    | Annot (_, _) -> assert false
    | Block l -> List.iter (print (n + indent)) l
    | Inline l -> List.iter (print n) l
    | Line s ->
        for _ = 1 to n do
          Buffer.add_char buf ' '
        done;
        Buffer.add_string buf s;
        Buffer.add_char buf '\n';
  in
  List.iter (print offset) l

let to_string ?offset ?indent l =
  let buf = Buffer.create 1000 in
  to_buffer ?offset ?indent buf l;
  Buffer.contents buf

let to_channel ?offset ?indent oc l =
  let buf = Buffer.create 1000 in
  to_buffer ?offset ?indent buf l;
  Buffer.output_buffer oc buf

let to_stdout ?offset ?indent l =
  to_channel ?offset ?indent stdout l
atd-2.1.0/atdgen/src/indent.mli000066400000000000000000000020701357165332000163030ustar00rootroot00000000000000(** Simple indentation utility for code generators *)

type t =
  | Line of string        (** single line (not indented) **)
  | Block of t list       (** indented sequence **)
  | Inline of t list      (** in-line sequence (not indented) **)
  | Annot of string * t (** arbitrary annotation **)

val paren : t -> t

val strip : t -> t

val concat : 'a -> 'a list -> 'a list

val to_buffer : ?offset:int -> ?indent:int -> Buffer.t -> t list -> unit
  (** Write to a buffer.

      @param offset defines the number of space characters
      to use for the left margin. Default: 0.

      @param indent defines the number of space characters to use for
      indenting blocks. Default: 2.
  *)

val to_string : ?offset:int -> ?indent:int -> t list -> string
  (** Write to a string. See [to_buffer] for the options. *)

val to_channel : ?offset:int -> ?indent:int -> out_channel -> t list -> unit
  (** Write to a channel. See [to_buffer] for the options. *)

val to_stdout : ?offset:int -> ?indent:int -> t list -> unit
  (** Write to [stdout]. See [to_buffer] for the options. *)
atd-2.1.0/atdgen/src/json.ml000066400000000000000000000070161357165332000156270ustar00rootroot00000000000000(*
  Mapping from ATD to JSON
*)

type json_float =
  | Float of int option (* max decimal places *)
  | Int

type json_adapter = {
  ocaml_adapter : string option;
  java_adapter : string option;
}

let no_adapter = {
  ocaml_adapter = None;
  java_adapter = None;
}

type json_list = Array | Object

type json_variant = { json_cons : string }

type json_field = {
  json_fname  : string;           (*  *)
  json_unwrapped : bool;
}

type json_record = {
  json_keep_nulls : bool; (* { ... }  *)
  json_record_adapter : json_adapter;
}

type json_sum = {
  json_sum_adapter : json_adapter;
  json_open_enum : bool;
  json_lowercase_tags : bool;
}

(*
   Note that json adapters are supported only by records and sums
   at this time.
   TODO: Support json adapters for all kinds of nodes rather than just
   sums and records, preferably without major code duplication.
   Maybe this can be achieved by turning json_repr
   into (json_repr * json_adapter).
*)
type json_repr =
  | Bool
  | Cell
  | Def
  | External
  | Field of json_field
  | Float of json_float
  | Int
  | List of json_list
  | Nullable
  | Option
  | Record of json_record
  | String
  | Sum of json_sum
  | Tuple
  | Unit
  | Variant of json_variant
  | Wrap (* should we add support for Base64 encoding of binary data? *)

let json_float_of_string s : [ `Float | `Int ] option =
  match s with
      "float" -> Some `Float
    | "int" -> Some `Int
    | _ -> None

let json_precision_of_string s =
  try Some (int_of_string s)
  with _ -> None

let get_json_precision an =
  Atd.Annot.get_opt_field
    ~parse:json_precision_of_string
    ~sections:["json"]
    ~field:"precision"
    an

let get_json_float an : json_float =
  match
    Atd.Annot.get_field
      ~parse:json_float_of_string
      ~default:`Float
      ~sections:["json"]
      ~field:"repr"
      an
  with
      `Float -> Float (get_json_precision an)
    | `Int -> Int

let json_list_of_string s : json_list option =
  match s with
  | "array" -> Some Array
  | "object" -> Some Object
  | _ -> (* error *) None

(*
   
   --> { ocaml_adapter = Some "Foo.Bar";
         java_adapter = None; }
*)
let get_json_adapter an =
  let ocaml_adapter =
    Atd.Annot.get_opt_field
      ~parse:(fun s -> Some s)
      ~sections:["json"]
      ~field:"adapter.ocaml"
      an
  in
  let java_adapter =
    Atd.Annot.get_opt_field
      ~parse:(fun s -> Some s)
      ~sections:["json"]
      ~field:"adapter.java"
      an
  in
  { ocaml_adapter;
    java_adapter }

let get_json_open_enum an =
  Atd.Annot.get_flag ~sections:["json"] ~field:"open_enum" an

let get_json_lowercase_tags an =
  Atd.Annot.get_flag ~sections:["json"] ~field:"lowercase_tags" an

let get_json_sum an = {
  json_sum_adapter = get_json_adapter an;
  json_open_enum = get_json_open_enum an;
  json_lowercase_tags = get_json_lowercase_tags an;
}

let get_json_list an =
  Atd.Annot.get_field
    ~parse:json_list_of_string
    ~default:Array
    ~sections:["json"]
    ~field:"repr"
    an

let get_json_cons default an =
  Atd.Annot.get_field
    ~parse:(fun s -> Some s)
    ~default
    ~sections:["json"]
    ~field:"name"
    an

let get_json_fname default an =
  Atd.Annot.get_field
    ~parse:(fun s -> Some s)
    ~default
    ~sections:["json"]
    ~field:"name"
    an

let get_json_keep_nulls an =
  Atd.Annot.get_flag
    ~sections:["json"]
    ~field:"keep_nulls"
    an

let get_json_record an =
  {
    json_keep_nulls = get_json_keep_nulls an;
    json_record_adapter = get_json_adapter an;
  }

let tests = [
]
atd-2.1.0/atdgen/src/json.mli000066400000000000000000000030061357165332000157730ustar00rootroot00000000000000(**
  Mapping from ATD to JSON
*)

(** Association between languages and json adapter for that language.
    The specification of each json adapter is language-specific. *)
type json_adapter = {
  ocaml_adapter : string option;
    (** A module implementing [normalize] and [restore]. *)

  java_adapter : string option;
    (** tbd *)
}

val no_adapter : json_adapter

type json_float =
  | Float of int option (* max decimal places *)
  | Int

type json_list = Array | Object

type json_variant = { json_cons : string }

type json_field = {
  json_fname  : string;           (*  *)
  json_unwrapped : bool;
}

type json_record = {
  json_keep_nulls : bool; (* { ... }  *)
  json_record_adapter : json_adapter;
}

type json_sum = {
  json_sum_adapter : json_adapter;
  json_open_enum : bool;
  json_lowercase_tags : bool;
}

(** The different kinds of ATD nodes with their json-specific options. *)
type json_repr =
  | Bool
  | Cell
  | Def
  | External
  | Field of json_field
  | Float of json_float
  | Int
  | List of json_list
  | Nullable
  | Option
  | Record of json_record
  | String
  | Sum of json_sum
  | Tuple
  | Unit
  | Variant of json_variant
  | Wrap

val get_json_list : Atd.Annot.t -> json_list

val get_json_float : Atd.Annot.t -> json_float

val get_json_cons : string -> Atd.Annot.t -> string

val get_json_fname : string -> Atd.Annot.t -> string

val get_json_record : Atd.Annot.t -> json_record

val get_json_sum : Atd.Annot.t -> json_sum

val tests : (string * (unit -> bool)) list
atd-2.1.0/atdgen/src/mapping.ml000066400000000000000000000110641357165332000163070ustar00rootroot00000000000000open Atd.Import

type loc = Atd.Ast.loc

(*
  Generic mapping, based on the core ATD types
*)
type ('a, 'b) mapping =
  | Unit of loc * 'a * 'b
  | Bool of loc * 'a * 'b
  | Int of loc * 'a * 'b
  | Float of loc * 'a * 'b
  | String of loc * 'a * 'b
  | Sum of loc * ('a, 'b) variant_mapping array * 'a * 'b
  | Record of loc * ('a, 'b) field_mapping array * 'a * 'b
  | Tuple of loc * ('a, 'b) cell_mapping array * 'a * 'b
  | List of loc * ('a, 'b) mapping * 'a * 'b
  | Option of loc * ('a, 'b) mapping * 'a * 'b
  | Nullable of loc * ('a, 'b) mapping * 'a * 'b
  | Wrap of loc * ('a, 'b) mapping * 'a * 'b
  | Name of loc * string * ('a, 'b) mapping list * 'a option * 'b option
  | External of loc * string * ('a, 'b) mapping list * 'a * 'b
  | Tvar of loc * string

and ('a, 'b) cell_mapping = {
  cel_loc : loc;
  cel_value : ('a, 'b) mapping;
  cel_arepr : 'a;
  cel_brepr : 'b
}

and ('a, 'b) field_mapping = {
  f_loc : loc;
  f_name : string;
  f_kind : Atd.Ast.field_kind;
  f_value : ('a, 'b) mapping;
  f_arepr : 'a;
  f_brepr : 'b
}

and ('a, 'b) variant_mapping = {
  var_loc : loc;
  var_cons : string;
  var_arg : ('a, 'b) mapping option;
  var_arepr : 'a;
  var_brepr : 'b
}

type ('a, 'b) def = {
  def_loc : loc;
  def_name : string;
  def_param : string list;
  def_value : ('a, 'b) mapping option;
  def_arepr : 'a;
  def_brepr : 'b;
}


let as_abstract = function
    Atd.Ast.Name (_, (loc, "abstract", l), a) ->
      if l <> [] then
        Error.error loc "\"abstract\" takes no type parameters";
      Some (loc, a)
  | _ ->
      None

let is_abstract x = as_abstract x <> None


let loc_of_mapping x =
  match (x : (_, _) mapping) with
    | Unit (loc, _, _)
    | Bool (loc, _, _)
    | Int (loc, _, _)
    | Float (loc, _, _)
    | String (loc, _, _)
    | Sum (loc, _, _, _)
    | Record (loc, _, _, _)
    | Tuple (loc, _, _, _)
    | List (loc, _, _, _)
    | Option (loc, _, _, _)
    | Nullable (loc, _, _, _)
    | Wrap (loc, _, _, _)
    | Name (loc, _, _, _, _)
    | External (loc, _, _, _, _)
    | Tvar (loc, _) -> loc


module Env = Map.Make (String)

let rec subst env (x : (_, _) mapping) =
  match x with
    Unit (_, _, _)
  | Bool (_, _, _)
  | Int (_, _, _)
  | Float (_, _, _)
  | String (_, _, _) -> x
  | Sum (loc, ar, a, b) ->
      Sum (loc, Array.map (subst_variant env) ar, a, b)
  | Record (loc, ar, a, b) ->
      Record (loc, Array.map (subst_field env) ar, a, b)
  | Tuple (loc, ar, a, b) ->
      Tuple (loc, Array.map (subst_cell env) ar, a, b)
  | List (loc, x, a, b) ->
      List (loc, subst env x, a, b)
  | Option (loc, x, a, b) ->
      Option (loc, subst env x, a, b)
  | Nullable (loc, x, a, b) ->
      Nullable (loc, subst env x, a, b)
  | Wrap (loc, x, a, b) ->
      Wrap (loc, subst env x, a, b)
  | Name (loc, name, args, a, b) ->
      Name (loc, name, List.map (subst env) args, a, b)
  | External (loc, name, args, a, b) ->
      External (loc, name, List.map (subst env) args, a, b)
  | Tvar (_, s) ->
      try Env.find s env
      with Not_found ->
        invalid_arg (sprintf "Mapping.subst_var: '%s" s)

and subst_variant env x =
  match x.var_arg with
      None -> x
    | Some v -> { x with var_arg = Some (subst env v) }

and subst_field env x =
  { x with f_value = subst env x.f_value }

and subst_cell env x =
  { x with cel_value = subst env x.cel_value }

(*
  Substitute type variables param in x by args
*)
let apply param x args =
  if List.length param <> List.length args then
    invalid_arg "Mapping.apply";
  let env =
    List.fold_left2
      (fun env var value -> Env.add var value env)
      Env.empty param args
  in
  subst env x


let rec find_name loc env visited name =
  if List.mem name visited then
    Error.error loc "Cyclic type definition"
  else
    let param, x = Env.find name env in
    (param, deref_expr env (name :: visited) x)

and deref_expr env visited x =
  match x with
    Name (loc, name, args, _, _) ->
      (try
         let param, x = find_name loc env visited name in
         apply param x args
       with Not_found -> x)
  | _ -> x

let make_deref
    (l : (bool * ('a, 'b) def list) list) :
    (('a, 'b) mapping -> ('a, 'b) mapping) =

  let defs =
    List.fold_left
      (fun env d ->
         match d.def_value with
             None -> env
           | Some v -> Env.add d.def_name (d.def_param, v) env)
      Env.empty (List.concat_map snd l) in

  fun x -> deref_expr defs [] x

(*
   Resolve names and unwrap `wrap` constructs
   (discarding annotations along the way)
*)
let rec unwrap (deref: ('a, 'b) mapping -> ('a, 'b) mapping) x =
  match deref x with
  | Wrap (_, x, _, _) -> unwrap deref x
  | x -> x
atd-2.1.0/atdgen/src/mapping.mli000066400000000000000000000037451357165332000164670ustar00rootroot00000000000000(** Generic decorated ATD AST.

    Decorating a tree means adding extra information to the nodes
    of an existing tree.

    The generic types provided here take two type parameters.
    They are meant to accommodate options relevant to two data representations
    (e.g. ocaml and json), so that we can produce code that converts
    between those two representations.
*)

type loc = Atd.Ast.loc

type ('a, 'b) mapping =
  | Unit of loc * 'a * 'b
  | Bool of loc * 'a * 'b
  | Int of loc * 'a * 'b
  | Float of loc * 'a * 'b
  | String of loc * 'a * 'b
  | Sum of loc * ('a, 'b) variant_mapping array * 'a * 'b
  | Record of loc * ('a, 'b) field_mapping array * 'a * 'b
  | Tuple of loc * ('a, 'b) cell_mapping array * 'a * 'b
  | List of loc * ('a, 'b) mapping * 'a * 'b
  | Option of loc * ('a, 'b) mapping * 'a * 'b
  | Nullable of loc * ('a, 'b) mapping * 'a * 'b
  | Wrap of loc * ('a, 'b) mapping * 'a * 'b
  | Name of loc * string * ('a, 'b) mapping list * 'a option * 'b option
  | External of loc * string * ('a, 'b) mapping list * 'a * 'b
  | Tvar of loc * string

and ('a, 'b) cell_mapping = {
  cel_loc : loc;
  cel_value : ('a, 'b) mapping;
  cel_arepr : 'a;
  cel_brepr : 'b
}

and ('a, 'b) field_mapping = {
  f_loc : loc;
  f_name : string;
  f_kind : Atd.Ast.field_kind;
  f_value : ('a, 'b) mapping;
  f_arepr : 'a;
  f_brepr : 'b
}

and ('a, 'b) variant_mapping = {
  var_loc : loc;
  var_cons : string;
  var_arg : ('a, 'b) mapping option;
  var_arepr : 'a;
  var_brepr : 'b
}

type ('a, 'b) def = {
  def_loc : loc;
  def_name : string;
  def_param : string list;
  def_value : ('a, 'b) mapping option;
  def_arepr : 'a;
  def_brepr : 'b;
}

val as_abstract : Atd.Ast.type_expr -> (loc * Atd.Ast.annot) option

val is_abstract : Atd.Ast.type_expr -> bool

val loc_of_mapping : ('a, 'b) mapping -> loc

val make_deref
  : (bool * ('a, 'b) def list) list
  -> ('a, 'b) mapping
  -> ('a, 'b) mapping

val unwrap
  : (('a, 'b) mapping -> ('a, 'b) mapping)
  -> ('a, 'b) mapping
  -> ('a, 'b) mapping
atd-2.1.0/atdgen/src/ob_emit.ml000066400000000000000000001157431357165332000163030ustar00rootroot00000000000000(*
  OCaml code generator for the biniou format.
*)


open Atd.Import
open Indent

open Atd.Ast
open Mapping
open Ob_mapping

(*
  OCaml code generator (biniou readers and writers)
*)


let make_ocaml_biniou_intf ~with_create buf deref defs =
  List.concat_map snd defs
  |> List.filter Ox_emit.include_intf
  |> List.iter (fun x ->
    let full_name = Ox_emit.get_full_type_name x in
    let writer_params =
      String.concat "" (
        List.map
          (fun s ->
             sprintf "\n  Bi_io.node_tag ->\
                      \n  (Bi_outbuf.t -> '%s -> unit) ->\
                      \n  (Bi_outbuf.t -> '%s -> unit) ->" s s)
          x.def_param
      )
    in
    let reader_params =
      String.concat "" (
        List.map (
          fun s ->
            sprintf
              "\n  (Bi_io.node_tag -> (Bi_inbuf.t -> '%s)) ->\
               \n  (Bi_inbuf.t -> '%s) ->" s s
        )
          x.def_param
      )
    in
    bprintf buf "(* Writers for type %s *)\n\n" x.def_name;

    bprintf buf "\
val %s_tag : Bi_io.node_tag
  (** Tag used by the writers for type {!%s}.
      Readers may support more than just this tag. *)

" x.def_name x.def_name;

    bprintf buf "\
val write_untagged_%s :%s
  Bi_outbuf.t -> %s -> unit
  (** Output an untagged biniou value of type {!%s}. *)

" x.def_name writer_params full_name x.def_name;

    bprintf buf "\
val write_%s :%s
  Bi_outbuf.t -> %s -> unit
  (** Output a biniou value of type {!%s}. *)

" x.def_name writer_params full_name x.def_name;

    bprintf buf "\
val string_of_%s :%s
  ?len:int -> %s -> string
  (** Serialize a value of type {!%s} into
      a biniou string. *)

" x.def_name writer_params full_name x.def_name;

    bprintf buf "(* Readers for type %s *)\n\n" x.def_name;

    bprintf buf "\
val get_%s_reader :%s
  Bi_io.node_tag -> (Bi_inbuf.t -> %s)
  (** Return a function that reads an untagged
      biniou value of type {!%s}. *)

" x.def_name reader_params full_name x.def_name;

    bprintf buf "\
val read_%s :%s
  Bi_inbuf.t -> %s
  (** Input a tagged biniou value of type {!%s}. *)

" x.def_name reader_params full_name x.def_name;

    bprintf buf "\
val %s_of_string :%s
  ?pos:int -> string -> %s
  (** Deserialize a biniou value of type {!%s}.
      @param pos specifies the position where
                 reading starts. Default: 0. *)

" x.def_name reader_params full_name x.def_name;

    Ox_emit.maybe_write_creator_intf ~with_create deref buf x
  )


let rec get_biniou_tag (x : ob_mapping) =
  match x with
    Unit (_, Unit, Unit) -> "Bi_io.unit_tag"
  | Bool (_, Bool, Bool) -> "Bi_io.bool_tag"
  | Int (_, Int _, Int b) ->
      (match b with
         `Uvint -> "Bi_io.uvint_tag"
       | `Svint -> "Bi_io.svint_tag"
       | `Int8 -> "Bi_io.int8_tag"
       | `Int16 -> "Bi_io.int16_tag"
       | `Int32 -> "Bi_io.int32_tag"
       | `Int64 -> "Bi_io.int64_tag"
      )
  | Float (_, Float, Float b) ->
      (match b with
         `Float32 -> "Bi_io.float32_tag"
       | `Float64 -> "Bi_io.float64_tag"
      )
  | String (_, String, String) -> "Bi_io.string_tag"
  | Sum (_, _, Sum _, Sum) -> "Bi_io.variant_tag"
  | Record (_, _, Record _, Record) -> "Bi_io.record_tag"
  | Tuple (_, _, Tuple, Tuple) -> "Bi_io.tuple_tag"
  | List (_, _, List _, List b) ->
      (match b with
         `Array -> "Bi_io.array_tag"
       | `Table -> "Bi_io.table_tag"
      )
  | Option (_, _, Option, Option)
  | Nullable (_, _, Nullable, Nullable) -> "Bi_io.num_variant_tag"
  | Wrap (_, x, Wrap _, Wrap) -> get_biniou_tag x

  | Name (_, s, _, None, None) -> sprintf "%s_tag" s
  | External (_, _, _,
              External (_, main_module, ext_name),
              External) ->
      sprintf "%s.%s_tag" main_module ext_name
  | Tvar (_, s) -> sprintf "%s_tag" (Ox_emit.name_of_var s)
  | _ -> assert false

let get_fields deref a =
  List.map (fun x ->
    let (ocamlf, binf) =
      match x.f_arepr, x.f_brepr with
      | Ocaml.Repr.Field o, Biniou.Field b -> o, b
      | _, _ -> assert false
    in
    let ocaml_default = Ox_emit.default_value x deref in
    (x, ocamlf.Ocaml.ocaml_fname , ocaml_default
    , (not (Atd.Ast.is_required x.f_kind))
    , binf.Biniou.biniou_unwrapped)
  ) (Array.to_list a)

let rec get_writer_name
    ?(paren = false)
    ?name_f
    ~tagged
    (x : ob_mapping) : string =

  let name_f =
    match name_f with
      Some f -> f
    | None ->
        if tagged then
          (fun s -> "write_" ^ s)
        else
          (fun s -> "write_untagged_" ^ s)
  in

  let un = if tagged then "" else "untagged_" in
  match x with
    Unit (_, Unit, Unit) ->
      sprintf "Bi_io.write_%sunit" un
  | Bool (_, Bool, Bool) ->
      sprintf "Bi_io.write_%sbool" un
  | Int (loc, Int o, Int b) ->
      (match o, b with
         Int, `Uvint -> sprintf "Bi_io.write_%suvint" un
       | Int, `Svint -> sprintf "Bi_io.write_%ssvint" un
       | Char, `Int8 -> sprintf "Bi_io.write_%schar" un
       | Int, `Int8 -> sprintf "Bi_io.write_%sint8" un
       | Int, `Int16 -> sprintf "Bi_io.write_%sint16" un
       | Int32, `Int32 -> sprintf "Bi_io.write_%sint32" un
       | Int64, `Int64 -> sprintf "Bi_io.write_%sint64" un
       | _ ->
           Error.error loc "Unsupported combination of OCaml/Biniou int types"
      )

  | Float (_, Float, Float b) ->
      (match b with
         `Float32 -> sprintf "Bi_io.write_%sfloat32" un
       | `Float64 -> sprintf "Bi_io.write_%sfloat64" un
      )
  | String (_, String, String) ->
      sprintf "Bi_io.write_%sstring" un

  | Tvar (_, s) ->
      sprintf "write_%s%s" un (Ox_emit.name_of_var s)

  | Name (_, s, args, None, None) ->
      let l = List.map get_writer_names args in
      let s = String.concat " " (name_f s :: l) in
      if paren && l <> [] then "(" ^ s ^ ")"
      else s

  | External (_, _, args,
              External (_, main_module, ext_name),
              External) ->
      let f = main_module ^ "." ^ name_f ext_name in
      let l = List.map get_writer_names args in
      let s = String.concat " " (f :: l) in
      if paren && l <> [] then "(" ^ s ^ ")"
      else s

  | _ -> assert false

and get_writer_names x =
  let tag = get_biniou_tag x in
  let write_untagged = get_writer_name ~paren:true ~tagged:false x in
  let write = get_writer_name ~paren:true ~tagged:true x in
  String.concat " " [ tag; write_untagged; write ]


let get_left_writer_name ~tagged name param =
  let args = List.map (fun s -> Tvar (dummy_loc, s)) param in
  get_writer_name ~tagged
    (Name (dummy_loc, name, args, None, None))

let get_left_to_string_name name param =
  let name_f s = "string_of_" ^ s in
  let args = List.map (fun s -> Tvar (dummy_loc, s)) param in
  get_writer_name ~tagged:true ~name_f
    (Name (dummy_loc, name, args, None, None))

(*
let make_writer_name tagged loc name args =
  let un = if tagged then "" else "untagged_" in
  let f = sprintf "write_%s%s" un name in
  let l =
    List.map (
      function
          `Tvar (loc, s) ->
            let name = name_of_var s in
            (* TODO (incomplete) *)
            [ sprintf "%s_tag" name;
              sprintf "write_%s" name ]
        | _ -> assert false
    ) args
  in
  String.concat " " (f :: List.flatten l)
*)

let rec get_reader_name
    ?(paren = false)
    ?name_f
    ~tagged
    (x : ob_mapping) : string =

  let name_f =
    match name_f with
      Some f -> f
    | None ->
        if tagged then
          (fun s -> "read_" ^ s)
        else
          (fun s -> sprintf "get_%s_reader" s)
  in

  let xreader s =
    if tagged then
      sprintf "Atdgen_runtime.Ob_run.read_%s" s
    else
      sprintf "Atdgen_runtime.Ob_run.get_%s_reader" s
  in
  match x with
    Unit (_, Unit, Unit) -> xreader "unit"

  | Bool (_, Bool, Bool) -> xreader "bool"

  | Int (loc, Int o, Int b) ->
      (match o, b with
         Int, `Uvint
       | Int, `Svint
       | Int, `Int8
       | Int, `Int16 -> xreader "int"
       | Char, `Int8 -> xreader "char"
       | Int32, `Int32 -> xreader "int32"
       | Int64, `Int64 -> xreader "int64"
       | _ ->
           Error.error loc "Unsupported combination of OCaml/Biniou int types"
      )

  | Float (_, Float, Float b) ->
      (match b with
         `Float32 -> xreader "float32"
       | `Float64 -> xreader "float64"
      )

  | String (_, String, String) -> xreader "string"

  | Tvar (_, s) ->
      let name = Ox_emit.name_of_var s in
      if tagged then
        sprintf "read_%s" name
      else
        sprintf "get_%s_reader" name

  | Name (_, s, args, None, None) ->
      let l = List.map get_reader_names args in
      let s = String.concat " " (name_f s :: l) in
      if paren && l <> [] then "(" ^ s ^ ")"
      else s

  | External (_, _, args,
              External (_, main_module, ext_name),
              External) ->
      let f = main_module ^ "." ^ name_f ext_name in
      let l = List.map get_reader_names args in
      let s = String.concat " " (f :: l) in
      if paren && l <> [] then "(" ^ s ^ ")"
      else s

  | _ -> assert false

and get_reader_names x =
  let get_reader = get_reader_name ~paren:true ~tagged:false x in
  let reader = get_reader_name ~paren:true ~tagged:true x in
  String.concat " " [ get_reader; reader ]


let get_left_reader_name ~tagged name param =
  let args = List.map (fun s -> Tvar (dummy_loc, s)) param in
  get_reader_name ~tagged (Name (dummy_loc, name, args, None, None))

let get_left_of_string_name name param =
  let name_f s = s ^ "_of_string" in
  let args = List.map (fun s -> Tvar (dummy_loc, s)) param in
  get_reader_name ~name_f ~tagged:true
    (Name (dummy_loc, name, args, None, None))


let rec make_writer ~tagged deref (x : ob_mapping) : Indent.t list =
  let un = if tagged then "" else "untagged_" in
  match x with
    Unit _
  | Bool _
  | Int _
  | Float _
  | String _
  | Name _
  | External _
  | Tvar _ -> [ Line (get_writer_name ~tagged x) ]

  | Sum (_, a, Sum x, Sum) ->
      let tick = Ocaml.tick x in
      let match_ =
        [
          Line "match x with";
          Block (
            Array.to_list (
              Array.map
                (fun x -> Inline (make_variant_writer deref tick x))
                a
            )
          )
        ]
      in
      let body =
        if tagged then
          Line "Bi_io.write_tag ob Bi_io.variant_tag;" :: match_
        else
          match_
      in
      [
        Annot ("fun", Line "fun ob x ->");
        Block body;
      ]

  | Record (_, a, Record o, Record) ->
      let body = make_record_writer deref tagged a o in
      [
        Annot ("fun", Line "fun ob x ->");
        Block body;
      ]

  | Tuple (_, a, Tuple, Tuple) ->
      let main =
        let len = Array.length a in
        let a =
          Array.mapi (
            fun i x ->
              [
                Line "(";
                Block [
                  Line (sprintf "let %s = x in (" (Ox_emit.nth "x" i len));
                  Block (make_writer ~tagged:true deref x.cel_value);
                  Line ") ob x";
                ];
                Line ");"
              ]
          ) a
        in
        [
          Line (sprintf "Bi_vint.write_uvint ob %i;" len);
          Inline (List.flatten (Array.to_list a))
        ]
      in
      let body =
        if tagged then
          Line "Bi_io.write_tag ob Bi_io.tuple_tag;" :: main
        else
          main
      in
      [
        Annot ("fun", Line "fun ob x ->");
        Block body;
      ]

  | List (_, x, List o, List b) ->
      (match o, b with
         List, `Array ->
           let tag = get_biniou_tag x in
           [
             Line (sprintf "Atdgen_runtime.Ob_run.write_%slist" un);
             Block [
               Line tag;
               Line "(";
               Block (make_writer ~tagged:false deref x);
               Line ")";
             ]
           ]
       | Array, `Array ->
           let tag = get_biniou_tag x in
           [
             Line (sprintf "Atdgen_runtime.Ob_run.write_%sarray" un);
             Block [
               Line tag;
               Line "(";
               Block (make_writer ~tagged deref x);
               Line ")";
             ]
           ]
       | list_kind, `Table ->
           let body = make_table_writer deref tagged list_kind x in
           [
             Annot ("fun", Line "fun ob x ->");
             Block body;
           ]
      )

  | Option (_, x, Option, Option)
  | Nullable (_, x, Nullable, Nullable) ->
      [
        Line (sprintf "Atdgen_runtime.Ob_run.write_%soption (" un);
        Block (make_writer ~tagged:true deref x);
        Line ")";
      ]

  | Wrap (_, x, Wrap o, Wrap) ->
      let simple_writer = make_writer ~tagged deref x in
      (match o with
         None -> simple_writer
       | Some { Ocaml.ocaml_unwrap; _ } ->
           [
             Line "fun ob x -> (";
             Block [
               Line (sprintf "let x = ( %s ) x in (" ocaml_unwrap);
               Block simple_writer;
               Line ") ob x)";
             ]
           ]
      )

  | _ -> assert false



and make_variant_writer deref tick x : Indent.t list =
  let o =
    match x.var_arepr, x.var_brepr with
      Variant o, Variant -> o
    | _ -> assert false
  in
  let ocaml_cons = o.Ocaml.ocaml_cons in
  match x.var_arg with
    None ->
      let h = Bi_io.string_of_hashtag (Bi_io.hash_name x.var_cons) false in
      [ Line (sprintf "| %s%s -> Bi_outbuf.add_char4 ob %C %C %C %C"
                tick ocaml_cons
                h.[0] h.[1] h.[2] h.[3]) ]
  | Some v ->
      let h = Bi_io.string_of_hashtag (Bi_io.hash_name x.var_cons) true in
      [
        Line (sprintf "| %s%s x ->" tick ocaml_cons);
        Block [
          Line (sprintf "Bi_outbuf.add_char4 ob %C %C %C %C;"
                  h.[0] h.[1] h.[2] h.[3]);
          Line "(";
          Block (make_writer ~tagged:true deref v);
          Line ") ob x"
        ]
      ]

and make_record_writer deref tagged a record_kind =
  let dot = Ocaml.dot record_kind in
  let fields = get_fields deref a in
  let write_length =
    (* count the number of defined optional fields in order
       to determine the length of the record *)
    let min_len =
      List.fold_left
        (fun n (_, _, _, opt, _) -> if opt then n else n + 1) 0 fields
    in
    let max_len = List.length fields in
    if min_len = max_len then
      [ Line (sprintf "Bi_vint.write_uvint ob %i;" max_len) ]
    else
      [
        (* Using a ref because many "let len = ... len + 1 in"
           cause ocamlopt to take a very long time to finish *)
        Line (sprintf "let len = ref %i in" min_len);
        Inline (
          List.fold_right (
            fun (_, ocaml_fname, default, opt, _) l ->
              if opt then
                let getfield =
                  sprintf "let x_%s = x%s%s in" ocaml_fname dot ocaml_fname in
                let setlen =
                  sprintf "if x_%s != %s then incr len;"
                    ocaml_fname (Option.value_exn default)
                in
                Line getfield :: Line setlen :: l
              else l
          ) fields []
        );
        Line "Bi_vint.write_uvint ob !len;"
      ]
  in

  let write_fields =
    List.concat_map (fun (x, ocaml_fname, ocaml_default, optional, unwrapped) ->
      let f_value =
        if unwrapped then Ocaml.unwrap_option (deref x.f_value)
        else x.f_value
      in
      let write_field_tag =
        let s = Bi_io.string_of_hashtag (Bi_io.hash_name x.f_name) true in
        sprintf "Bi_outbuf.add_char4 ob %C %C %C %C;"
          s.[0] s.[1] s.[2] s.[3]
      in
      let app v =
        [
          Line write_field_tag;
          Line "(";
          Block (make_writer ~tagged:true deref f_value);
          Line (sprintf ") ob %s;" v);
        ]
      in
      let v =
        if optional then
          sprintf "x_%s" ocaml_fname
        else
          sprintf "x%s%s" dot ocaml_fname
      in
      if unwrapped then
        [
          Line (sprintf "(match %s with None -> () | Some x ->" v);
          Block (app "x");
          Line ");"
        ]
      else if optional then
        [
          Line (sprintf "if %s != %s then (" v (Option.value_exn ocaml_default));
          Block (app v);
          Line ");"
        ]
      else
        app v
    ) fields in

  let main = write_length @ write_fields in

  if tagged then
    Line "Bi_io.write_tag ob Bi_io.record_tag;" :: main
  else
    main



and make_table_writer deref tagged list_kind x =
  let a, record_kind =
    match deref x with
      Record (_, a, Record record_kind, Record) -> a, record_kind
    | _ ->
        Error.error (loc_of_mapping x) "Not a record type"
  in
  let dot = Ocaml.dot record_kind in
  let let_len =
    match list_kind with
      List -> Line "let len = List.length x in"
    | Array -> Line "let len = Array.length x in"
  in
  let iter2 =
    match list_kind with
      List -> "Atdgen_runtime.Ob_run.list_iter2"
    | Array -> "Atdgen_runtime.Ob_run.array_iter2"
  in
  let l = Array.to_list a in
  let write_header =
    Line (sprintf "Bi_vint.write_uvint ob %i;" (Array.length a)) ::
    List.concat_map (
      fun x ->
        [ Line (sprintf "Bi_io.write_hashtag ob (%i) true;"
                  (Bi_io.hash_name x.f_name));
          Line (sprintf "Bi_io.write_tag ob %s;"
                  (get_biniou_tag x.f_value)) ]
    ) l
  in
  let write_record =
    List.concat_map (fun x ->
      [ Line "(";
        Block (make_writer ~tagged:false deref x.f_value);
        Line ")";
        Block [ Line (sprintf "ob x%s%s;" dot x.f_name) ] ]
    ) l
  in
  let write_items =
    [ Line (iter2 ^ " (fun ob x ->");
      Block write_record;
      Line ") ob x;" ]
  in
  let main =
    [
      let_len;
      Line "Bi_vint.write_uvint ob len;";
      Line "if len > 0 then (";
      Block (write_header @ write_items);
      Line ");"
    ]
  in
  if tagged then
    Line "Bi_io.write_tag ob Bi_io.table_tag;" :: main
  else
    main


let study_record ~ocaml_version fields =
  let field_assignments =
    List.fold_right (
      fun (_, name, default, opt, _) field_assignments ->
        let v =
          match default with
            None ->
              assert (not opt);
              begin match ocaml_version with
                | Some (maj, min) when (maj > 4 || maj = 4 && min >= 3) ->
                    "Obj.magic (Sys.opaque_identity 0.0)"
                | _ -> "Obj.magic 0.0"
              end
          | Some s ->
              s
        in
        let init = Line (sprintf "let field_%s = ref (%s) in" name v) in
        let create = Line (sprintf "%s = !field_%s;" name name) in
        (init, create) :: field_assignments
    ) fields []
  in
  let init_fields, create_record_fields = List.split field_assignments in
  let n, mapping =
    List.fold_left (
      fun (i, acc) (_, _, _, opt, _) ->
        if not opt then
          (i+1, (Some i :: acc))
        else
          (i, (None :: acc))
    ) (0, []) fields
  in
  let mapping = Array.of_list (List.rev mapping) in

  let create_record = [ Line "{"; Block create_record_fields; Line "}" ] in

  let k = n / 31 + (if n mod 31 > 0 then 1 else 0) in
  let init_bits =
    List.init k (fun i -> Line (sprintf "let bits%i = ref 0 in" i)) in
  let final_bits = Array.make k 0 in
  for z0 = 0 to List.length fields - 1 do
    match mapping.(z0) with
      None -> ()
    | Some z ->
        let i = z / 31 in
        let j = z mod 31 in
        final_bits.(i) <- final_bits.(i) lor (1 lsl j);
  done;
  let set_bit z0 =
    match mapping.(z0) with
      None -> []
    | Some z ->
        let i = z / 31 in
        let j = z mod 31 in
        [ Line (sprintf "bits%i := !bits%i lor 0x%x;" i i (1 lsl j)) ]
  in
  let check_bits =
    let bool_expr =
      Array.mapi (fun i x -> sprintf "!bits%i <> 0x%x" i x) final_bits
      |> Array.to_list
      |> String.concat " || "
    in
    let bit_fields =
      let a = Array.init k (fun i -> sprintf "!bits%i" i) in
      sprintf "[| %s |]" (String.concat "; " (Array.to_list a))
    in
    let field_names =
      let l =
        List.fold_right (
          fun (x, _, _, opt, _) acc ->
            if not opt then
              sprintf "%S" x.f_name :: acc
            else
              acc
        ) fields []
      in
      sprintf "[| %s |]" (String.concat "; " l)
    in
    if k = 0 then []
    else
      [ Line (sprintf "if %s then Atdgen_runtime.Ob_run.missing_fields %s %s;"
                bool_expr bit_fields field_names) ]
  in
  init_fields, init_bits, set_bit, check_bits, create_record


let wrap_body ~tagged expected_tag body =
  if tagged then
    [
      Annot ("fun", Line "fun ib ->");
      Block [
        Line (sprintf "if Bi_io.read_tag ib <> %i then \
                       Atdgen_runtime.Ob_run.read_error_at ib;"
                expected_tag);
        Inline body;
      ]
    ]
  else
    [
      Annot ("fun", Line "fun tag ->");
      Block [
        Line (sprintf "if tag <> %i then \
                       Atdgen_runtime.Ob_run.read_error () else"
                expected_tag);
        Block [
          Line "fun ib ->";
          Block body;
        ]
      ]
    ]

let wrap_bodies ~tagged l =
  if tagged then
    let cases =
      List.map (
        fun (expected_tag, body) ->
          Inline [
            Line (sprintf "| %i -> " expected_tag);
            Block body;
          ]
      ) l
    in
    [
      Line "fun ib ->";
      Block [
        Line "match Bi_io.read_tag ib with";
        Block [
          Inline cases;
          Line "| _ -> Atdgen_runtime.Ob_run.read_error_at ib"
        ]
      ]
    ]
  else
    let cases =
      List.map (
        fun (expected_tag, body) ->
          Inline [
            Line (sprintf "| %i -> " expected_tag);
            Block [
              Line "(fun ib ->";
              Block body;
              Line ")";
            ]
          ]
      ) l
    in
    [
      Line "function";
      Block [
        Inline cases;
        Line "| _ -> Atdgen_runtime.Ob_run.read_error ()"
      ]
    ]


let rec make_reader
    deref ~tagged ~ocaml_version ?type_annot (x : ob_mapping)
  : Indent.t list =
  match x with
    Unit _
  | Bool _
  | Int _
  | Float _
  | String _
  | Name _
  | External _
  | Tvar _ -> [ Line (get_reader_name ~tagged x) ]

  | Sum (_, a, Sum x, Sum) ->
      let tick = Ocaml.tick x in
      let body =
        [
          Line "Bi_io.read_hashtag ib (fun ib h has_arg ->";
          Block [
            Line "match h, has_arg with";
            Block [
              Inline (
                Array.to_list (
                  Array.map
                    (fun x ->
                       Inline (make_variant_reader ~ocaml_version
                                 deref type_annot tick x)
                    )
                    a
                )
              );
              Line "| _ -> Atdgen_runtime.Ob_run.unsupported_variant h has_arg";
            ]
          ];
          Line ")"
        ]
      in
      wrap_body ~tagged Bi_io.variant_tag body

  | Record (loc, a, Record o, Record) ->
      Ocaml.obj_unimplemented loc o;
      let body = make_record_reader deref ~ocaml_version type_annot a in
      wrap_body ~tagged Bi_io.record_tag body

  | Tuple (_, a, Tuple, Tuple) ->
      let body = make_tuple_reader deref ~ocaml_version a in
      wrap_body ~tagged Bi_io.tuple_tag body

  | List (loc, x, List o, List b) ->
      (match o, b with
         List, `Array ->
           let f =
             if tagged then "Atdgen_runtime.Ob_run.read_list"
             else "Atdgen_runtime.Ob_run.get_list_reader"
           in
           [
             Line (f ^ " (");
             Block (make_reader deref ~ocaml_version ~tagged:false x);
             Line ")";
           ]
       | Array, `Array ->
           let f =
             if tagged then "Atdgen_runtime.Ob_run.read_array"
             else "Atdgen_runtime.Ob_run.get_array_reader"
           in
           [
             Line (f ^ " (");
             Block (make_reader deref ~ocaml_version ~tagged:false x);
             Line ")";
           ]
       | list_kind, `Table ->
           (* Support table format and regular array format *)
           let body1 =
             make_table_reader ~ocaml_version deref loc list_kind x in
           let body2 =
             let f =
               match list_kind with
                 List -> "Atdgen_runtime.Ob_run.read_list_value"
               | Array -> "Atdgen_runtime.Ob_run.read_array_value"
             in
             [
               Line (f ^ " (");
               Block (make_reader deref ~tagged:false ~ocaml_version x);
               Line ") ib";
             ]
           in
           wrap_bodies ~tagged [ Bi_io.table_tag, body1;
                                 Bi_io.array_tag, body2 ]
      )

  | Option (_, x, Option, Option)
  | Nullable (_, x, Nullable, Nullable) ->
      let body = [
        Line "match Char.code (Bi_inbuf.read_char ib) with";
        Block [
          Line "| 0 -> None";
          Line "| 0x80 ->";
          Block [
            Line "Some (";
            Block [
              Line "(";
              Block (make_reader deref ~tagged:true ~ocaml_version x);
              Line ")";
              Block [ Line "ib"];
            ];
            Line ")"
          ];
          Line "| _ -> Atdgen_runtime.Ob_run.read_error_at ib";
        ]
      ]
      in
      wrap_body ~tagged Bi_io.num_variant_tag body

  | Wrap (_, x, Wrap o, Wrap) ->
      let simple_reader = make_reader deref ~tagged ~ocaml_version x in
      (match o with
         None -> simple_reader
       | Some { Ocaml.ocaml_wrap ; _ } ->
           if tagged then
             [
               Line "fun ib ->";
               Block [
                 Line (sprintf "( %s ) ((" ocaml_wrap);
                 Block simple_reader;
                 Line ") ib)";
               ]
             ]
           else
             [
               Line "fun tag ib ->";
               Block [
                 Line (sprintf "( %s ) ((" ocaml_wrap);
                 Block simple_reader;
                 Line ") tag ib)";
               ]
             ]
      )
  | _ -> assert false


and make_variant_reader ~ocaml_version deref type_annot tick x : Indent.t list =
  let o =
    match x.var_arepr, x.var_brepr with
      Variant o, Variant -> o
    | _ -> assert false
  in
  let ocaml_cons = o.Ocaml.ocaml_cons in
  match x.var_arg with
    None ->
      let h = Bi_io.hash_name x.var_cons in
      let typed_cons = Ox_emit.opt_annot type_annot (tick ^ ocaml_cons) in
      [ Line (sprintf "| %i, false -> %s" h typed_cons) ]
  | Some v ->
      let h = Bi_io.hash_name x.var_cons in
      [
        Line (sprintf "| %i, true -> (%s%s (" h tick ocaml_cons);
        Block [
          Block [
            Line "(";
            Block (make_reader deref ~tagged:true ~ocaml_version v);
            Line ") ib";
          ];
          Line (sprintf ")%s)" (Ox_emit.insert_annot type_annot));
        ];
      ]

and make_record_reader
    deref ~ocaml_version type_annot
    a =
  let fields = get_fields deref a in
  let init_fields, init_bits, set_bit, check_bits, create_record =
    study_record ~ocaml_version fields
  in

  let body =
    let a = Array.of_list fields in
    let cases =
      Array.mapi (
        fun i (x, name, _, _, unwrapped) ->
          let f_value =
            if unwrapped then Ocaml.unwrap_option (deref x.f_value)
            else x.f_value
          in
          let wrap l =
            if unwrapped then
              [
                Line "Some (";
                Block l;
                Line ")"
              ]
            else l
          in
          let read_value =
            [
              Line "(";
              Block (make_reader deref ~tagged:true ~ocaml_version f_value);
              Line ") ib"
            ]
          in
          Inline [
            Line (sprintf "| %i ->" (Bi_io.hash_name x.f_name));
            Block [
              Line (sprintf "field_%s := (" name);
              Block (wrap read_value);
              Line ");";
              Inline (set_bit i);
            ];
          ]
      ) a
    in
    [
      Line "match Bi_io.read_field_hashtag ib with";
      Block [
        Inline (Array.to_list cases);
        Line "| _ -> Bi_io.skip ib";
      ]
    ]
  in

  [
    Inline init_fields;
    Inline init_bits;
    Line "let len = Bi_vint.read_uvint ib in";
    Line "for i = 1 to len do";
    Block body;
    Line "done;";
    Inline check_bits;
    Line "(";
    Block create_record;
    Line (sprintf "%s)" (Ox_emit.insert_annot type_annot));
  ]


and make_tuple_reader deref ~ocaml_version a =
  let cells =
    Array.map (
      fun x ->
        match x.cel_arepr with
          Ocaml.Repr.Cell f -> x, f.Ocaml.ocaml_default
        | _ -> assert false
    ) a
  in
  let min_length =
    let n = ref (Array.length cells) in
    (try
       for i = Array.length cells - 1 downto 0 do
         let _, default = cells.(i) in
         if default = None then (
           n := i + 1;
           raise Exit
         )
       done
     with Exit -> ());
    !n
  in
  let tup_len = Array.length a in

  let read_cells =
    List.flatten (
      Array.to_list (
        Array.mapi (
          fun i (x, default) ->
            let read_value =
              make_reader deref ~ocaml_version ~tagged:true
                x.cel_value in
            let get_value =
              if i < min_length then
                [
                  Line "(";
                  Block read_value;
                  Line ") ib";
                ]
              else
                [
                  Line (sprintf "if len >= %i then (" (i+1));
                  Block read_value;
                  Line ") ib";
                  Line "else";
                  Block [
                    Line
                      (match default with None -> assert false | Some s -> s)
                  ]
                ]
            in
            [
              Line (sprintf "let x%i =" i);
              Block get_value;
              Line "in"
            ]
        ) cells
      )
    )
  in

  let make_tuple =
    sprintf "(%s)"
      (String.concat ", "
         (Array.to_list (Array.mapi (fun i _ -> sprintf "x%i" i) a)))
  in
  let req_fields =
    let acc = ref [] in
    for i = Array.length cells - 1 downto 0 do
      let _, default = cells.(i) in
      if default = None then
        acc := string_of_int i :: !acc
    done;
    sprintf "[ %s ]" (String.concat "; " !acc)
  in
  [
    Line "let len = Bi_vint.read_uvint ib in";
    Line (sprintf
            "if len < %i then Atdgen_runtime.Ob_run.missing_tuple_fields len %s;"
            min_length req_fields);
    Inline read_cells;
    Line (sprintf "for i = %i to len - 1 do Bi_io.skip ib done;" tup_len);
    Line make_tuple
  ]


and make_table_reader deref ~ocaml_version loc list_kind x =
  let empty_list, to_list =
    match list_kind with
      List -> "[ ]", (fun s -> "Array.to_list " ^ s)
    | Array -> "[| |]", (fun s -> s)
  in
  let fields =
    match deref x with
      Record (loc, a, Record o, Record) ->
        Ocaml.obj_unimplemented loc o;
        get_fields deref a
    | _ ->
        Error.error loc "Not a list or array of records"
  in
  let init_fields, init_bits, set_bit, check_bits, create_record =
    study_record ~ocaml_version fields
  in
  let cases =
    Array.to_list (
      Array.mapi (
        fun i (x, name, _, _, _) ->
          Inline [
            Line (sprintf "| %i ->" (Bi_io.hash_name x.f_name));
            Block [
              Inline (set_bit i);
              Line "let read =";
              Block [
                Line "(";
                Block (make_reader deref ~tagged:false ~ocaml_version x.f_value);
                Line ")";
                Block [ Line "tag" ]
              ];
              Line "in";
              Line (sprintf "(fun ib -> field_%s := read ib)" name);
            ]
          ]
      ) (Array.of_list fields)
    )
  in
  [
    Line "let row_num = Bi_vint.read_uvint ib in";
    Line ("if row_num = 0 then " ^ empty_list);
    Line "else";
    Block [
      Line "let col_num = Bi_vint.read_uvint ib in";
      Inline init_fields;
      Inline init_bits;
      Line "let readers =";
      Block [
        Line "Atdgen_runtime.Ob_run.array_init2 col_num ib (";
        Block [
          Line "fun col ib ->";
          Block [
            Line "let h = Bi_io.read_field_hashtag ib in";
            Line "let tag = Bi_io.read_tag ib in";
            Line "match h with";
            Block cases;
            Block [ Line "| _ -> (fun ib -> Bi_io.skip ib)" ]
          ]
        ];
        Line ")";
      ];
      Line "in";
      Inline check_bits;
      Line "let a = Array.make row_num (Obj.magic 0) in";
      Line "for row = 0 to row_num - 1 do";
      Block [
        Line "for i = 0 to Array.length readers - 1 do";
        Block [ Line "readers.(i) ib" ];
        Line "done;";
        Line "a.(row) <-";
        Block create_record;
      ];
      Line "done;";
      Line (to_list "a")
    ]
  ]

let make_ocaml_biniou_writer ~original_types deref is_rec let1 let2 def =
  let x = Option.value_exn def.def_value in
  let name = def.def_name in
  let type_constraint = Ox_emit.get_type_constraint ~original_types def in
  let param = def.def_param in
  let tag = get_biniou_tag (deref x) in
  let write_untagged = get_left_writer_name ~tagged:false name param in
  let write = get_left_writer_name ~tagged:true name param in
  let to_string = get_left_to_string_name name param in
  let write_untagged_expr = make_writer deref ~tagged:false x in
  let eta_expand = is_rec && not (Ox_emit.is_lambda write_untagged_expr) in
  let needs_annot = Ox_emit.needs_type_annot x in
  let extra_param, extra_args =
    match eta_expand, needs_annot with
    | true, false -> " ob x", " ob x"
    | true, true -> sprintf " ob (x : %s)" type_constraint, " ob x"
    | false, false -> "", ""
    | false, true -> "", ""
  in
  let type_annot =
    match Ox_emit.needs_type_annot x with
    | true -> Some (sprintf "Bi_outbuf.t -> %s -> unit" type_constraint)
    | false -> None
  in
  [
    Line (sprintf "%s %s_tag = %s" let1 name tag);
    Line (sprintf "%s %s = ("
            let2
            (Ox_emit.opt_annot_def type_annot
               (write_untagged ^ extra_param)));
    Block (List.map Indent.strip write_untagged_expr);
    Line (sprintf ")%s" extra_args);
    Line (sprintf "%s %s ob x =" let2 write);
    Block [
      Line (sprintf "Bi_io.write_tag ob %s;" tag);
      Line (sprintf "%s ob x" write_untagged);
    ];
    Line (sprintf "%s %s ?(len = 1024) x =" let2 to_string);
    Block [
      Line "let ob = Bi_outbuf.create len in";
      Line (sprintf "%s ob x;" write);
      Line "Bi_outbuf.contents ob"
    ]
  ]

let make_ocaml_biniou_reader ~original_types ~ocaml_version
    deref is_rec let1 let2 def =
  let x = Option.value_exn def.def_value in
  let name = def.def_name in
  let type_constraint = Ox_emit.get_type_constraint ~original_types def in
  let param = def.def_param in
  let get_reader = get_left_reader_name ~tagged:false name param in
  let read = get_left_reader_name ~tagged:true name param in
  let of_string = get_left_of_string_name name param in
  let type_annot =
    match Ox_emit.needs_type_annot x with
    | true -> Some type_constraint
    | false -> None
  in
  let get_reader_expr =
    make_reader deref ~tagged:false ~ocaml_version ?type_annot x in
  let read_expr = make_reader deref ~tagged:true ~ocaml_version ?type_annot x in
  let eta_expand1 = is_rec && not (Ox_emit.is_lambda get_reader_expr) in
  let eta_expand2 = is_rec && not (Ox_emit.is_lambda read_expr) in
  let extra_param1, extra_args1 =
    if eta_expand1 then " tag", " tag"
    else "", ""
  in
  let extra_param2, extra_args2 =
    if eta_expand2 then " ib", " ib"
    else "", ""
  in
  [
    Line (sprintf "%s %s%s = (" let1 get_reader extra_param1);
    Block (List.map Indent.strip get_reader_expr);
    Line (sprintf ")%s" extra_args1);
    Line (sprintf "%s %s%s = (" let2 read extra_param2);
    Block (List.map Indent.strip read_expr);
    Line (sprintf ")%s" extra_args2);
    Line (sprintf "%s %s ?pos s =" let2 of_string);
    Block [
      Line (sprintf "%s (Bi_inbuf.from_string ?pos s)" read)
    ]
  ]

let make_ocaml_biniou_impl ~with_create ~original_types ~ocaml_version
    buf deref defs =
  defs
  |> List.concat_map (fun (is_rec, l) ->
    let l = List.filter (fun x -> x.def_value <> None) l in
    let writers =
      List.map_first (fun ~is_first def ->
          let let1, let2 = Ox_emit.get_let ~is_rec ~is_first in
          make_ocaml_biniou_writer
            ~original_types deref is_rec let1 let2 def
      ) l
    in
    let readers =
      List.map_first (fun ~is_first def ->
          let let1, let2 = Ox_emit.get_let ~is_rec ~is_first in
          make_ocaml_biniou_reader ~ocaml_version
            ~original_types deref is_rec let1 let2 def
      ) l
    in
    List.flatten (writers @ readers))
  |> Indent.to_buffer buf;
  Ox_emit.maybe_write_creator_impl ~with_create deref buf defs


(*
  Glue
*)

let make_mli
    ~header ~opens ~with_typedefs ~with_create ~with_fundefs
    ocaml_typedefs deref defs =
  let buf = Buffer.create 1000 in
  bprintf buf "%s\n" header;
  Ox_emit.write_opens buf opens;
  if with_typedefs then
    bprintf buf "%s\n" ocaml_typedefs;
  if with_typedefs && with_fundefs then
    bprintf buf "\n";
  if with_fundefs then
    make_ocaml_biniou_intf ~with_create buf deref defs;
  Buffer.contents buf

let make_ml
    ~header ~opens ~with_typedefs ~with_create ~with_fundefs ~original_types
    ~ocaml_version
    ocaml_typedefs deref defs =
  let buf = Buffer.create 1000 in
  bprintf buf "%s\n" header;
  Ox_emit.write_opens buf opens;
  if with_typedefs then
    bprintf buf "%s\n" ocaml_typedefs;
  if with_typedefs && with_fundefs then
    bprintf buf "\n";
  if with_fundefs then
    make_ocaml_biniou_impl
      ~with_create ~original_types ~ocaml_version
      buf deref defs;
  Buffer.contents buf

let make_ocaml_files
    ~opens
    ~with_typedefs
    ~with_create
    ~with_fundefs
    ~all_rec
    ~pos_fname
    ~pos_lnum
    ~type_aliases
    ~force_defaults:_
    ~ocaml_version
    ~pp_convs
    atd_file out =
  let ((head, m0), _) =
    match atd_file with
      Some file ->
        Atd.Util.load_file
          ~expand:false ~inherit_fields:true ~inherit_variants:true
          ?pos_fname ?pos_lnum
          file
    | None ->
        Atd.Util.read_channel
          ~expand:false ~inherit_fields:true ~inherit_variants:true
          ?pos_fname ?pos_lnum
          stdin
  in
  let tsort =
    if all_rec then
      function m -> [ (true, m) ]
    else
      Atd.Util.tsort
  in
  let m1 = tsort m0 in
  let defs1 = defs_of_atd_modules m1 in
  Xb_emit.check defs1;
  let (m1', original_types) =
    Atd.Expand.expand_module_body ~keep_poly:true m0
  in
  let m2 = tsort m1' in
  (* m0 = original type definitions
     m1 = original type definitions after dependency analysis
     m2 = monomorphic type definitions after dependency analysis *)
  let ocaml_typedefs =
    Ocaml.ocaml_of_atd ~pp_convs ~target:Biniou ~type_aliases (head, m1) in
  let defs = defs_of_atd_modules m2 in
  let header =
    let src =
      match atd_file with
        None -> "stdin"
      | Some path -> sprintf "%S" (Filename.basename path)
    in
    sprintf {|(* Auto-generated from %s *)
              [@@@ocaml.warning "-27-32-35-39"]|} src
  in
  let mli =
    make_mli ~header ~opens ~with_typedefs ~with_create ~with_fundefs
      ocaml_typedefs (Mapping.make_deref defs1) defs1
  in
  let ml =
    make_ml ~header ~opens ~with_typedefs ~with_create ~with_fundefs
      ~original_types ~ocaml_version ocaml_typedefs
      (Mapping.make_deref defs) defs
  in
  Ox_emit.write_ocaml out mli ml
atd-2.1.0/atdgen/src/ob_emit.mli000066400000000000000000000006221357165332000164410ustar00rootroot00000000000000(** OCaml-Biniou code generator. *)

val make_ocaml_files
  : opens:string list
  -> with_typedefs:bool
  -> with_create:bool
  -> with_fundefs:bool
  -> all_rec:bool
  -> pos_fname:string option
  -> pos_lnum:int option
  -> type_aliases:string option
  -> force_defaults:_ (* not used *)
  -> ocaml_version:(int * int) option
  -> pp_convs:Ocaml.pp_convs
  -> string option -> Ox_emit.target -> unit
atd-2.1.0/atdgen/src/ob_mapping.ml000066400000000000000000000102601357165332000167640ustar00rootroot00000000000000open Atd.Import
open Atd.Ast
open Mapping

type ob_mapping =
  (Ocaml.Repr.t, Biniou.biniou_repr) Mapping.mapping

(*
  Translation of the types into the ocaml/biniou mapping.
*)

let rec mapping_of_expr (x : type_expr) : ob_mapping =
  match x with
    Sum (loc, l, an) ->
      let ocaml_t = Ocaml.Repr.Sum (Ocaml.get_ocaml_sum Biniou an) in
      let biniou_t = Biniou.Sum in
      Sum (loc, Array.of_list (List.map mapping_of_variant l),
           ocaml_t, biniou_t)

  | Record (loc, l, an) ->
      let ocaml_t = Ocaml.Repr.Record (Ocaml.get_ocaml_record Biniou an) in
      let ocaml_field_prefix = Ocaml.get_ocaml_field_prefix Biniou an in
      let biniou_t = Biniou.Record in
      Record (loc,
              Array.of_list
                (List.map (mapping_of_field ocaml_field_prefix) l),
              ocaml_t, biniou_t)

  | Tuple (loc, l, _) ->
      let ocaml_t = Ocaml.Repr.Tuple in
      let biniou_t = Biniou.Tuple in
      Tuple (loc, Array.of_list (List.map mapping_of_cell l),
             ocaml_t, biniou_t)

  | List (loc, x, an) ->
      let ocaml_t = Ocaml.Repr.List (Ocaml.get_ocaml_list Biniou an) in
      let biniou_t = Biniou.List (Biniou.get_biniou_list an) in
      List (loc, mapping_of_expr x, ocaml_t, biniou_t)

  | Option (loc, x, _) ->
      let ocaml_t = Ocaml.Repr.Option in
      let biniou_t = Biniou.Option in
      Option (loc, mapping_of_expr x, ocaml_t, biniou_t)

  | Nullable (loc, x, _) ->
      let ocaml_t = Ocaml.Repr.Nullable in
      let biniou_t = Biniou.Nullable in
      Nullable (loc, mapping_of_expr x, ocaml_t, biniou_t)

  | Shared (_, _, _) ->
      failwith "Sharing is no longer supported"

  | Wrap (loc, x, a) ->
      let ocaml_t =
        Ocaml.Repr.Wrap (Ocaml.get_ocaml_wrap ~type_param:[] Biniou loc a) in
      let json_t = Biniou.Wrap in
      Wrap (loc, mapping_of_expr x, ocaml_t, json_t)

  | Name (loc, (_, s, l), an) ->
      (match s with
         "unit" ->
           Unit (loc, Unit, Biniou.Unit)
       | "bool" ->
           Bool (loc, Bool, Biniou.Bool)
       | "int" ->
           let o = Ocaml.get_ocaml_int Biniou an in
           let b = Biniou.get_biniou_int an in
           Int (loc, Int o, Biniou.Int b)
       | "float" ->
           let b = Biniou.get_biniou_float an in
           Float (loc, Float, Biniou.Float b)
       | "string" ->
           String (loc, String, Biniou.String)
       | s ->
           Name (loc, s, List.map mapping_of_expr l, None, None)
      )
  | Tvar (loc, s) ->
      Tvar (loc, s)

and mapping_of_cell (cel_loc, x, an) =
  { cel_loc
  ; cel_value = mapping_of_expr x
  ; cel_arepr = Ocaml.Repr.Cell
        { Ocaml.ocaml_default = Ocaml.get_ocaml_default Biniou an
        ; ocaml_fname = ""
        ; ocaml_mutable = false
        ; ocaml_fdoc = Atd.Doc.get_doc cel_loc an
        }
  ; cel_brepr = Biniou.Cell
  }

and mapping_of_variant = function
  | Inherit _ -> assert false
  | Variant (var_loc, (var_cons, an), o) ->
      { var_loc
      ; var_cons
      ; var_arg = Option.map mapping_of_expr o
      ; var_arepr = Ocaml.Repr.Variant
            { Ocaml.ocaml_cons = Ocaml.get_ocaml_cons Biniou var_cons an
            ; ocaml_vdoc = Atd.Doc.get_doc var_loc an
            }
      ; var_brepr = Biniou.Variant
      }

and mapping_of_field ocaml_field_prefix = function
  | `Inherit _ -> assert false
  | `Field (f_loc, (f_name, f_kind, an), x) ->
      let { Ox_mapping.ocaml_default; unwrapped } =
        Ox_mapping.analyze_field Biniou f_loc f_kind an in
      { f_loc
      ; f_name
      ; f_kind
      ; f_value = mapping_of_expr x
      ; f_arepr = Ocaml.Repr.Field
            { Ocaml.ocaml_default
            ; ocaml_fname =
                Ocaml.get_ocaml_fname Biniou (ocaml_field_prefix ^ f_name) an
            ; ocaml_mutable = Ocaml.get_ocaml_mutable Biniou an
            ; ocaml_fdoc = Atd.Doc.get_doc f_loc an
            }
      ; f_brepr = Biniou.Field { Biniou.biniou_unwrapped = unwrapped };
      }



let def_of_atd atd =
  Ox_emit.def_of_atd atd ~target:Biniou ~external_:Biniou.External
    ~mapping_of_expr ~def:Biniou.Def

let defs_of_atd_module l =
  List.map (function Atd.Ast.Type def -> def_of_atd def) l

let defs_of_atd_modules l =
  List.map (fun (is_rec, l) -> (is_rec, defs_of_atd_module l)) l
atd-2.1.0/atdgen/src/ob_mapping.mli000066400000000000000000000003631357165332000171400ustar00rootroot00000000000000(** OCaml-Biniou decorated ATD AST. *)

type ob_mapping =
    (Ocaml.Repr.t, Biniou.biniou_repr) Mapping.mapping

val defs_of_atd_modules
  : ('a * Atd.Ast.module_body) list
  -> ('a * (Ocaml.Repr.t, Biniou.biniou_repr) Mapping.def list) list
atd-2.1.0/atdgen/src/ob_spe.ml000066400000000000000000000003131357165332000161160ustar00rootroot00000000000000
(*
  Optimization of the biniou representation
*)

let get_table_info deref x =
  match deref x with
      `Record y -> y
    | _ ->
        Error.error (Atd.Ast.loc_of_type_expr x) "Not a record type"
atd-2.1.0/atdgen/src/obuckle_emit.ml000066400000000000000000000555211357165332000173240ustar00rootroot00000000000000open Atd.Import
open Indent

type param =
  { deref
    : (Ocaml.Repr.t, Json.json_repr) Mapping.mapping
      -> (Ocaml.Repr.t, Json.json_repr) Mapping.mapping;
  }

let target : Ocaml.target = Bucklescript

let open_enum_not_supported () =
  failwith "open_enum is not supported in bucklescript mode"

let runtime_module = "Atdgen_codec_runtime"

let decoder_ident = sprintf "%s.Decode.%s" runtime_module

let encoder_ident = sprintf "%s.Encode.%s" runtime_module

let decoder_make = decoder_ident "make"

let encoder_make = encoder_ident "make"

let decoder_t s = sprintf "%s %s" s (decoder_ident "t")

let encoder_t s = sprintf "%s %s" s (encoder_ident "t")

let make_json_string s = Yojson.Safe.to_string (`String s)

let type_annot_str = Option.value ~default:"_"

let destruct_sum (x : Oj_mapping.t) =
  let open Mapping in
  match x with
  | Sum (_, a, Sum x, Sum j) ->
      let tick = Ocaml.tick x in
      if j.json_open_enum then open_enum_not_supported ();
      tick, a
  | Unit _ -> Error.error (loc_of_mapping x) "Cannot destruct unit"
  | Bool _ -> Error.error (loc_of_mapping x) "Cannot destruct bool"
  | Int _ -> Error.error (loc_of_mapping x) "Cannot destruct int"
  | Float _ -> Error.error (loc_of_mapping x) "Cannot destruct float"
  | String _ -> Error.error (loc_of_mapping x) "Cannot destruct string"
  | Name (_,name,_,_,_) ->
      Error.error (loc_of_mapping x) ("Cannot destruct name " ^ name)
  | External _ -> Error.error (loc_of_mapping x) "Cannot destruct external"
  | Tvar _ -> Error.error (loc_of_mapping x) "Cannot destruct tvar"
  | Record _ -> Error.error (loc_of_mapping x) "Cannot destruct record"
  | Tuple _ -> Error.error (loc_of_mapping x) "Cannot destruct tuple"
  | List _ -> Error.error (loc_of_mapping x) "Cannot destruct list"
  | Option _ -> Error.error (loc_of_mapping x) "Cannot destruct option"
  | Nullable _ -> Error.error (loc_of_mapping x) "Cannot destruct nullable"
  | Wrap _ -> Error.error (loc_of_mapping x) "Cannot destruct wrap"
  | _ -> Error.error (loc_of_mapping x) "Cannot destruct unknown type"


let make_ocaml_bs_intf ~with_create buf deref defs =
  List.concat_map snd defs
  |> List.filter Ox_emit.include_intf
  |> List.iter (fun (x : (_, _) Mapping.def) ->
    let s = x.def_name in
    let full_name = Ox_emit.get_full_type_name x in
    let params t =
      String.concat " " (
        List.map (fun s -> sprintf "%s ->" (t ("'" ^ s))) x.def_param
      ) in
    let read_params = params decoder_t in
    let write_params = params encoder_t in
    bprintf buf "val read_%s : %s %s\n\n"
      s read_params (decoder_t full_name);
    bprintf buf "val write_%s : %s %s\n\n"
      s write_params (encoder_t full_name);
    Ox_emit.maybe_write_creator_intf ~with_create deref buf x
  )

let unwrap_f_value { Ox_emit.mapping; unwrapped; _} (p : param) =
  if unwrapped then
    Ocaml.unwrap_option (p.deref mapping.f_value)
  else
    mapping.f_value

let rec get_reader_name
    ?(paren = false)
    ?(name_f = fun s -> "read_" ^ s)
    p (x : Oj_mapping.t) : string =
  match x with
    Unit (_, Unit, Unit) -> decoder_ident "unit"
  | Bool (_, Bool, Bool) -> decoder_ident "bool"
  | Int (_, Int o, Int) ->
      decoder_ident (
        match o with
        | Int -> "int"
        | Char ->  "char"
        | Int32 -> "int32"
        | Int64 -> "int64"
        | Float -> "float"
      )
  | Float (_, Float, Float _) -> decoder_ident "float"
  | String (_, String, String) -> decoder_ident "string"
  | Tvar (_, s) -> "read_" ^ Ox_emit.name_of_var s

  | Name (_, s, args, None, None) ->
      let l = List.map (get_reader_name ~paren:true p) args in
      let s = String.concat " " (name_f s :: l) in
      if paren && l <> [] then "(" ^ s ^ ")"
      else s

  | External (_, _, args,
              External (_, main_module, ext_name),
              External) ->
      let f = main_module ^ "." ^ name_f ext_name in
      let l = List.map (get_reader_name ~paren:true p) args in
      let s = String.concat " " (f :: l) in
      if paren && l <> [] then "(" ^ s ^ ")"
      else s

  | _ -> assert false

let read_with_adapter adapter reader =
  match adapter.Json.ocaml_adapter with
  | None -> reader
  | Some adapter_path ->
      let normalize =
        Oj_mapping.json_normalizer_of_adapter_path adapter_path
      in
      [
        Line (
          sprintf "%s %s (" (decoder_ident "adapter") normalize
        );
        Block reader;
        Line ")";
      ]

let rec make_reader ?type_annot p (x : Oj_mapping.t) : Indent.t list =
  match x with
    Unit _
  | Bool _
  | Int _
  | Float _
  | String _
  | Name _
  | External _
  | Tvar _ -> [ Indent.Line (get_reader_name p x) ]
  | Record (loc, a, Record o, Record j) ->
      let reader =
        [ Line (sprintf "%s (fun json ->" decoder_make)
        ; Block (make_record_reader ?type_annot p loc a j)
        ; Line ")"
        ]
      in
      let adapter = j.json_record_adapter in
      read_with_adapter adapter reader
  | Tuple (_, a, Tuple, Tuple) ->
      [ Line (decoder_ident (sprintf "tuple%d" (Array.length a)))
      ; Block (
          a
          |> Array.to_list
          |> List.map (fun (cm : (_, _) Mapping.cell_mapping) ->
            Block (make_reader p cm.cel_value)
            |> Indent.paren
          )
        )
      ]
  | List (loc, x, List o, List j) ->
      (match j with
         Array ->
           [ Line (sprintf "%s ("
                     (match o with
                      | List -> decoder_ident "list"
                      | Array -> decoder_ident "array"))
           ; Block (make_reader p x)
           ; Line ")"
           ]
       | Object ->
           let _k, v = Ox_emit.get_assoc_type p.deref loc x in (* TODO key wrap *)
           [ Line (sprintf "%s ("
                     (match o with
                      | List -> decoder_ident "obj_list"
                      | Array -> decoder_ident "obj_array"))
           ; Block (make_reader p v)
           ; Line ")"
           ]
      )
  | Sum (_, a, Sum osum, Sum j) ->
      if j.json_open_enum then open_enum_not_supported ();
      let cases =
        Array.to_list a
        |> List.map
          (fun (r : (Ocaml.Repr.t, Json.json_repr) Mapping.variant_mapping) ->
             let (o, j) =
               match r.var_arepr, r.var_brepr with
               | Ocaml.Repr.Variant o, Json.Variant j -> o, j
               | _ -> assert false in
             ( r.var_arg
             , j.json_cons
             , o.ocaml_cons
             )
          ) in
      let cases =
        let tick = Ocaml.tick osum in
        cases
        |> List.concat_map (fun (arg, j, o) ->
          let codec_cons =
            match arg with
            | None ->
                [Line (sprintf "`Single (%s%s)" tick o)]
            | Some v ->
                [ Line "`Decode ("
                ; Inline (make_reader p v)
                ; Line (
                    sprintf "|> %s (fun x -> ((%s%s x) : %s))"
                      (decoder_ident "map")
                      tick o (type_annot_str type_annot))
                ; Line ")"
                ]
          in
          [Block
             [ Line "("
             ; Line (sprintf "%S" j)
             ; Line ","
             ; Block codec_cons
             ; Line ")"
             ]
          ])
        |> Indent.concat (Line ";")
      in
      let standard_reader =
        [ Line (decoder_ident "enum")
        ; Line "["
        ; Block cases
        ; Line "]"
        ]
      in
      let adapter = j.json_sum_adapter in
      read_with_adapter adapter standard_reader
  | Wrap (_, x, Wrap o, Wrap) ->
      (match o with
       | None -> make_reader p x
       | Some w ->
           [ Line "("
           ; Block (make_reader p x)
           ; Line (sprintf ") |> (%s (%s))" (decoder_ident "map") w.ocaml_wrap)
           ])
  | Option (_, x, Option, Option) ->
      [ Line (sprintf "%s (" (decoder_ident "option_as_constr"))
      ; Block (make_reader p x)
      ; Line ")"
      ]
  | Nullable (_, x, Nullable, Nullable) ->
      [ Line (sprintf "%s (" (decoder_ident "nullable"))
      ; Block (make_reader p x)
      ; Line ")"
      ]
  | _ -> failwith "TODO: make reader"

and make_record_reader ?type_annot
    (p : param)
    _loc
    (a : (Ocaml.Repr.t, Json.json_repr) Mapping.field_mapping array)
    _json_options
  =
  let create_record =
    Ox_emit.get_fields p.deref a
    |> List.map (function ({ Ox_emit. mapping; ocaml_fname; json_fname
                           ; ocaml_default ; optional ; unwrapped
                           } as field) ->
        let f_value = unwrap_f_value field p in
        Block
          [ Line (sprintf "%s =" ocaml_fname)
          ; Block
              [ Line (decoder_ident "decode")
              ; Line "("
              ; Block
                  [ Inline (
                      make_reader p (
                        if unwrapped then
                          f_value
                        else
                          mapping.f_value
                      )
                    )
                  ; Line (
                      sprintf "|> %s"
                        (match unwrapped, optional, ocaml_default with
                         | true, true, Some _
                         | true, true, None ->
                             sprintf "%s \"%s\""
                               (decoder_ident "fieldOptional")
                               json_fname
                         | false, true, Some default
                         | false, false, Some default ->
                             sprintf "%s \"%s\" %s"
                               (decoder_ident "fieldDefault")
                               json_fname
                               default
                         | false, false, None
                         | true, false, None
                         | false, true, None ->
                             sprintf "%s \"%s\""
                               (decoder_ident "field")
                               json_fname
                         | true, false, _ -> assert false
                        )
                    )
                  ]
              ; Line ") json;"
              ]
          ])
  in
  [ Line "("
  ; Block
      [ Line "({"
      ; Block create_record
      ; Line (sprintf "} : %s)" (type_annot_str type_annot))
      ]
  ; Line ")"
  ]

let get_left_reader_name p name param =
  let args = List.map (fun s -> Mapping.Tvar (Atd.Ast.dummy_loc, s)) param in
  get_reader_name p (Mapping.Name (Atd.Ast.dummy_loc, name, args, None, None))

let make_ocaml_bs_reader p ~original_types is_rec let1 _let2
    (def : (_, _) Mapping.def) =
  let x = Option.value_exn def.def_value in
  let name = def.def_name in
  let param = def.def_param in
  let read = get_left_reader_name p name param in
  let type_annot =
    if Ox_emit.needs_type_annot x then (
      Some (Ox_emit.get_type_constraint ~original_types def)
    ) else (
      None
    )
  in
  let reader_expr = make_reader ?type_annot p x in
  let eta_expand = is_rec && not (Ox_emit.is_lambda reader_expr) in
  let extra_param, extra_args =
    if eta_expand then " js", " js"
    else "", ""
  in
  [
    Line (sprintf "%s %s%s = (" let1 read extra_param);
    Block (List.map Indent.strip reader_expr);
    Line (sprintf ")%s" extra_args);
  ]

let rec get_writer_name
    ?(paren = false)
    ?(name_f = fun s -> "write_" ^ s)
    (p : param) (x : Oj_mapping.t) : string =
  match x with
  | Unit (_, Ocaml.Repr.Unit, Unit) ->
      encoder_ident "unit"
  | Bool (_, Bool, Bool) ->
      encoder_ident "bool"
  | Int (_, Int o, Int) ->
      encoder_ident (
        match o with
        | Int -> "int"
        | Char ->  "char"
        | Int32 -> "int32"
        | Int64 -> "int64"
        | Float -> "float"
      )
  | Float (_, Float, Float j) ->
      encoder_ident (
        match j with
        | Float None -> "float"
        (* TODO *)
        | Float (Some _precision) -> sprintf "float"
        | Int -> "float"
      )

  | String (_, String, String) -> encoder_ident "string"

  | Tvar (_, s) -> "write_" ^ (Ox_emit.name_of_var s)

  | Name (_, s, args, None, None) ->
      let l = List.map (get_writer_name ~paren:true p) args in
      let s = String.concat " " (name_f s :: l) in
      if paren && l <> [] then "(" ^ s ^ ")"
      else s

  | External (_, _, args,
              External (_, main_module, ext_name),
              External) ->
      let f = main_module ^ "." ^ name_f ext_name in
      let l = List.map (get_writer_name ~paren:true p) args in
      let s = String.concat " " (f :: l) in
      if paren && l <> [] then "(" ^ s ^ ")"
      else s

  | _ -> assert false

let write_with_adapter adapter writer =
  match adapter.Json.ocaml_adapter with
  | None -> writer
  | Some adapter_path ->
      let restore = Oj_mapping.json_restorer_of_adapter_path adapter_path in
      [
        Line (
          sprintf "%s %s (" (encoder_ident "adapter") restore
        );
        Block writer;
        Line ")";
      ]

let get_left_writer_name p name param =
  let args = List.map (fun s -> Mapping.Tvar (Atd.Ast.dummy_loc, s)) param in
  get_writer_name p (Name (Atd.Ast.dummy_loc, name, args, None, None))

let rec make_writer ?type_annot p (x : Oj_mapping.t) : Indent.t list =
  match x with
    Unit _
  | Bool _
  | Int _
  | Float _
  | String _
  | Name _
  | External _
  | Tvar _ -> [ Line (get_writer_name p x) ]
  | Tuple (_, a, Tuple, Tuple) ->
      [ Line (encoder_ident (sprintf "tuple%d" (Array.length a)))
      ; Block (
          Array.to_list a
          |> List.map (fun (cm : (_, _) Mapping.cell_mapping) ->
            Block (make_writer p cm.cel_value)
            |> Indent.paren
          )
        )
      ]
  | List (loc, x, List o, List j) ->
      (match j with
         Array ->
           [ Line (sprintf "%s ("
                     (match o with
                      | List -> encoder_ident "list"
                      | Array -> encoder_ident "array"))
           ; Block (make_writer p x)
           ; Line ")"
           ]
       | Object ->
           let _k, v = Ox_emit.get_assoc_type p.deref loc x in
           [ Line (sprintf "%s (fun (t : %s) ->"
               encoder_make (type_annot_str type_annot))
           ; Block
               [ Line (sprintf "%s |>"
                         (match o with
                          | List -> "t"
                          | Array -> "Array.to_list t"))
               ; Line "List.map ("
               ; Block
                   [ Line "fun (key, value) ->"
                   ; Block
                       [ Line (encoder_ident "field")
                       ; Block
                           [ Line "("
                           ; Block (make_writer p v)
                           ; Line ")"
                           ]
                       ; Block
                           [ Line "~name:key" (* TODO unwrap keys? *)
                           ; Line "value";
                           ]
                       ]
                   ]
               ; Line ") |>"
               ; Line (encoder_ident "obj")
               ]
           ; Line ")"
           ]
      )
  | Record (_, a, Record o, Record j) ->
      let writer =
        [ Line (sprintf "%s (fun (t : %s) ->"
                  encoder_make (type_annot_str type_annot))
        ; Block (make_record_writer p a o)
        ; Line ")"
        ]
      in
      write_with_adapter j.json_record_adapter writer
  | Sum (_, _a, Sum _osum, Sum j) ->
      if j.json_open_enum then open_enum_not_supported ();
      let standard_writer = make_sum_writer ?type_annot p x in
      let adapter = j.json_sum_adapter in
      write_with_adapter adapter standard_writer

  | Wrap (_, x, Wrap o, Wrap) ->
      begin match o with
        | None -> make_writer p x
        | Some { Ocaml.ocaml_unwrap ; ocaml_wrap_t = _ ; ocaml_wrap = _ } ->
            [ Block (make_writer p x)
            ; Line (sprintf "|> %s (%s)" (encoder_ident "contramap")
                      ocaml_unwrap)
            ]
      end
  | Nullable (_, x, Nullable, Nullable) ->
      [ Line (sprintf "%s (" (encoder_ident "nullable"))
      ; Block (make_writer p x)
      ; Line ")"
      ]
  | Option (_, x, Option, Option) ->
      [ Line (sprintf "%s (" (encoder_ident "option_as_constr"))
      ; Block (make_writer p x)
      ; Line ")"
      ]
  | _ -> []

and make_record_writer p a _record_kind =
  let write_record =
    Ox_emit.get_fields p.deref a
    |> List.map
      (fun ({ Ox_emit. mapping; ocaml_fname; json_fname
            ; unwrapped ; optional ; ocaml_default } as field) ->
        let f_value = unwrap_f_value field p in
        Block
          [ Line (
              match unwrapped, optional, ocaml_default with
              | true, true, None
              | true, true, Some _ ->
                  encoder_ident "field_o"
              | false, false, Some default ->
                  encoder_ident (sprintf "field ~default:%s" default)
              | false, false, None
              | false, true, _ ->
                  encoder_ident "field"
              | true, false, _ ->
                  assert false
            )
          ; Block
              [ Line "("
              ; Inline (make_writer p (
                  if unwrapped then
                    f_value
                  else
                    mapping.f_value
                ))
              ; Line ")"
              ]
          ; Line (sprintf "~name:%S" json_fname)
          ; Line (sprintf "t.%s" ocaml_fname)
          ]
      )
    |> Indent.concat (Line ";") in
  [ Line "("
  ; Line (encoder_ident "obj")
  ; Block
      [ Line "["
      ; Block write_record
      ; Line "]"
      ]
  ; Line ")"
  ]

and make_sum_writer ?type_annot (p : param)
    (sum : (Ocaml.Repr.t, Json.json_repr) Mapping.mapping) =
  let tick, a = destruct_sum (p.deref sum) in
  let cases =
    a
    |> Array.map (
      fun (x : (Ocaml.Repr.t, Json.json_repr) Mapping.variant_mapping) ->
        let o, j =
          match x.var_arepr, x.var_brepr with
          | Ocaml.Repr.Variant o, Json.Variant j -> o, j
          | _ -> assert false in
        let ocaml_cons = o.Ocaml.ocaml_cons in
        let json_cons = j.Json.json_cons in
        Inline (
          begin match x.var_arg with
            | None ->
                [ Line (sprintf "| %s%s ->" tick ocaml_cons)
                ; Line (sprintf "%s %s" (encoder_ident "constr0")
                          (make_json_string json_cons))
                ]
            | Some v ->
                [ Line (sprintf "| %s%s x ->" tick ocaml_cons)
                ; Line (sprintf "%s %s (" (encoder_ident "constr1")
                          (make_json_string json_cons))
                ; Block (make_writer p v)
                ; Line ") x"
                ]
          end)
    )
    |> Array.to_list
  in
  [ Line (sprintf "%s (fun (x : %s) -> match x with"
            (encoder_ident "make") (type_annot_str type_annot))
  ; Block cases
  ; Line ")"]

let make_ocaml_bs_writer p ~original_types is_rec let1 _let2
    (def : (_, _) Mapping.def) =
  let x = Option.value_exn def.def_value in
  let name = def.def_name in
  let type_annot =
    if Ox_emit.needs_type_annot x then (
      Some (Ox_emit.get_type_constraint ~original_types def)
    ) else (
      None
    )
  in
  let param = def.def_param in
  let write = get_left_writer_name p name param in
  let writer_expr = make_writer ?type_annot p x in
  let eta_expand = is_rec && not (Ox_emit.is_lambda writer_expr) in
  let extra_param, extra_args =
    if eta_expand then " js", " js"
    else "", ""
  in
  [
    Line (sprintf "%s %s%s = (" let1 write extra_param);
    Block (List.map Indent.strip writer_expr);
    Line (sprintf ")%s" extra_args);
  ]

let make_ocaml_bs_impl
    ~with_create
    ~original_types
    buf deref defs =
  let p = {deref = deref;} in
  defs
  |> List.concat_map (fun (is_rec, l) ->
    let l = List.filter
        (fun (x : (Ocaml.Repr.t, Json.json_repr) Mapping.def) ->
           x.def_value <> None) l in
    let writers =
      List.map_first (fun ~is_first def ->
        let let1, let2 = Ox_emit.get_let ~is_rec ~is_first in
        make_ocaml_bs_writer p ~original_types is_rec let1 let2 def
      ) l in
    let readers =
      List.map_first (fun ~is_first def ->
        let let1, let2 = Ox_emit.get_let ~is_rec ~is_first in
        make_ocaml_bs_reader p ~original_types is_rec let1 let2 def
      ) l
    in
    List.flatten (writers @ readers))
  |> Indent.to_buffer buf;
  Ox_emit.maybe_write_creator_impl ~with_create deref buf defs

let make_ml
    ~opens
    ~header
    ~with_typedefs
    ~with_create
    ~with_fundefs
    ~original_types
    ocaml_typedefs deref defs =
  let buf = Buffer.create 1000 in
  bprintf buf "%s\n" header;
  Ox_emit.write_opens buf opens;
  if with_typedefs then
    bprintf buf "%s\n" ocaml_typedefs;
  if with_typedefs && with_fundefs then
    bprintf buf "\n";
  if with_fundefs then
    make_ocaml_bs_impl ~with_create ~original_types buf deref defs;
  Buffer.contents buf

let make_mli
    ~opens
    ~header
    ~with_typedefs
    ~with_create
    ~with_fundefs
    ~original_types:_
    ocaml_typedefs deref defs =
  let buf = Buffer.create 1000 in
  bprintf buf "%s\n" header;
  Ox_emit.write_opens buf opens;
  if with_typedefs then
    bprintf buf "%s\n" ocaml_typedefs;
  if with_typedefs && with_fundefs then
    bprintf buf "\n";
  if with_fundefs then
    make_ocaml_bs_intf ~with_create buf deref defs;
  Buffer.contents buf

let make_ocaml_files
    ~opens
    ~with_typedefs
    ~with_create
    ~with_fundefs
    ~all_rec
    ~pos_fname
    ~pos_lnum
    ~type_aliases
    ~force_defaults:_
    ~ocaml_version
    ~pp_convs:_
    atd_file out =
  let ((head, m0), _) =
    match atd_file with
      Some file ->
        Atd.Util.load_file
          ~expand:false ~inherit_fields:true ~inherit_variants:true
          ?pos_fname ?pos_lnum
          file
    | None ->
        Atd.Util.read_channel
          ~expand:false ~inherit_fields:true ~inherit_variants:true
          ?pos_fname ?pos_lnum
          stdin
  in

  let tsort =
    if all_rec then
      function m -> [ (true, m) ]
    else
      Atd.Util.tsort
  in
  let m1 = tsort m0 in
  let defs1 = Oj_mapping.defs_of_atd_modules m1 ~target in
  let (m1', original_types) =
    Atd.Expand.expand_module_body ~keep_poly:true m0
  in
  let m2 = tsort m1' in
  (* m0 = original type definitions
     m1 = original type definitions after dependency analysis
     m2 = monomorphic type definitions after dependency analysis *)
  let ocaml_typedefs =
    Ocaml.ocaml_of_atd ~pp_convs:(Ppx []) ~target
      ~type_aliases (head, m1) in
  let defs = Oj_mapping.defs_of_atd_modules m2 ~target in
  let header =
    let src =
      match atd_file with
        None -> "stdin"
      | Some path -> sprintf "%S" (Filename.basename path)
    in
    sprintf {|(* Auto-generated from %s *)
              [@@@ocaml.warning "-27-32-35-39"]|} src
  in
  let ml =
    make_ml ~opens ~header ~with_typedefs ~with_create ~with_fundefs ~original_types
      ocaml_typedefs (Mapping.make_deref defs) defs
  in
  let mli =
    make_mli ~opens ~header ~with_typedefs ~with_create ~with_fundefs ~original_types
      ocaml_typedefs (Mapping.make_deref defs1) defs1
  in
  Ox_emit.write_ocaml out mli ml
atd-2.1.0/atdgen/src/obuckle_emit.mli000066400000000000000000000005111357165332000174620ustar00rootroot00000000000000
val make_ocaml_files
  :  opens:string list
  -> with_typedefs:bool
  -> with_create:bool
  -> with_fundefs:bool
  -> all_rec:bool
  -> pos_fname:string option
  -> pos_lnum:int option
  -> type_aliases:string option
  -> force_defaults:'a
  -> ocaml_version:'b
  -> pp_convs:'c
  -> string option
  -> Ox_emit.target
  -> unit
atd-2.1.0/atdgen/src/ocaml.ml000066400000000000000000000566241357165332000157620ustar00rootroot00000000000000
(*
  Translation from ATD types into OCaml types and pretty-printing.

  This is derived from the ATD pretty-printer (atd_print.ml).
*)

open Atd.Import

open Easy_format
open Atd.Ast
open Mapping

type pp_convs =
  | Camlp4 of string list
  | Ppx of string list

(* Type mapping from ATD to OCaml *)

type atd_ocaml_sum = Classic | Poly
type atd_ocaml_record = Record | Object

type atd_ocaml_int = Int | Char | Int32 | Int64 | Float
type atd_ocaml_list = List | Array

type atd_ocaml_wrap = {
  ocaml_wrap_t : string;
  ocaml_wrap : string;
  ocaml_unwrap : string;
}

type atd_ocaml_field = {
  ocaml_default : string option;
  ocaml_fname : string;
  ocaml_mutable : bool;
  ocaml_fdoc : Atd.Doc.doc option;
}

type atd_ocaml_variant = {
  ocaml_cons : string;
  ocaml_vdoc : Atd.Doc.doc option;
}

type atd_ocaml_def = {
  ocaml_predef : bool;
  ocaml_ddoc : Atd.Doc.doc option;
}

let tick = function
  | Poly -> "`"
  | Classic -> ""

let dot = function
  | Record -> "."
  | Object -> "#"

module Repr = struct
  type t =
    | Unit
    | Bool
    | Int of atd_ocaml_int
    | Float
    | String
    | Sum of atd_ocaml_sum
    | Record of atd_ocaml_record
    | Tuple
    | List of atd_ocaml_list
    | Option
    | Nullable
    | Wrap of atd_ocaml_wrap option
    | Name of string
    | External of (string * string * string)
        (*
          (module providing the type,
           module providing everything else,
           type name)
        *)

    | Cell of atd_ocaml_field
    | Field of atd_ocaml_field
    | Variant of atd_ocaml_variant
    | Def of atd_ocaml_def
end

type target = Default | Biniou | Json | Validate | Bucklescript


let ocaml_int_of_string s : atd_ocaml_int option =
  match s with
      "int" -> Some Int
    | "char" -> Some Char
    | "int32" -> Some Int32
    | "int64" -> Some Int64
    | "float" -> Some Float
    | _ -> None

let string_of_ocaml_int (x : atd_ocaml_int) =
  match x with
      Int -> "int"
    | Char -> "Char.t"
    | Int32 -> "Int32.t"
    | Int64 -> "Int64.t"
    | Float -> "float"

let ocaml_sum_of_string s : atd_ocaml_sum option =
  match s with
      "classic" -> Some Classic
    | "poly" -> Some Poly
    | _ -> None

let ocaml_record_of_string s : atd_ocaml_record option =
  match s with
      "record" -> Some Record
    | "object" -> Some Object
    | _ -> None

let ocaml_list_of_string s : atd_ocaml_list option =
  match s with
      "list" -> Some List
    | "array" -> Some Array
    | _ -> None

let string_of_ocaml_list (x : atd_ocaml_list) =
  match x with
      List -> "list"
    | Array -> "Atdgen_runtime.Util.ocaml_array"

let path_of_target (target : target) =
  match target with
    | Default -> [ "ocaml" ]
    | Biniou -> [ "ocaml_biniou"; "ocaml" ]
    | Json -> [ "ocaml_json"; "ocaml" ]
    | Bucklescript -> ["ocaml_bs"; "ocaml"]
    | Validate -> [ "ocaml_validate"; "ocaml" ]

let get_ocaml_int target an =
  let path = path_of_target target in
  Atd.Annot.get_field
    ~parse:ocaml_int_of_string
    ~default:Int
    ~sections:path
    ~field:"repr"
    an

let get_ocaml_type_path target atd_name an =
  let x =
    match atd_name with
        "unit" -> `Unit
      | "bool" -> `Bool
      | "int" -> `Int (get_ocaml_int target an)
      | "float" -> `Float
      | "string" -> `String
      | s -> `Name s
  in
  match x with
      `Unit -> "unit"
    | `Bool -> "bool"
    | `Int x -> string_of_ocaml_int x
    | `Float -> "float"
    | `String -> "string"
    | `Name s -> s

let get_ocaml_sum target an =
  let path = path_of_target target in
  Atd.Annot.get_field
    ~parse:ocaml_sum_of_string
    ~default:Poly
    ~sections:path
    ~field:"repr"
    an

let get_ocaml_field_prefix target an =
  let path = path_of_target target in
  Atd.Annot.get_field
    ~parse:(fun s -> Some s)
    ~default:""
    ~sections:path
    ~field:"field_prefix"
    an

let get_ocaml_record target an =
  let path = path_of_target target in
  Atd.Annot.get_field
    ~parse:ocaml_record_of_string
    ~default:Record
    ~sections:path
    ~field:"repr"
    an

let get_ocaml_list target an =
  let path = path_of_target target in
  Atd.Annot.get_field
    ~parse:ocaml_list_of_string
    ~default:List
    ~sections:path
    ~field:"repr"
    an

let get_ocaml_wrap ~type_param target loc an =
  let path = path_of_target target in
  let module_ =
    Atd.Annot.get_opt_field
      ~parse:(fun s -> Some s)
      ~sections:path
      ~field:"module"
      an
  in
  let default field =
    Option.map (fun s ->
      sprintf "%s.%s" s field) module_
  in
  let default_t field =
    Option.map (fun s ->
      let type_param =
        match List.map (sprintf "'%s") type_param with
        | [] -> ""
        | x::[] -> sprintf "%s " x
        | param -> sprintf "(%s) " (String.concat ", " type_param) in
      sprintf "%s%s.%s" type_param s field) module_
  in
  let t =
    Atd.Annot.get_field
      ~parse:(fun s -> Some (Some s))
      ~default:(default_t "t")
      ~sections:path
      ~field:"t"
      an
  in
  let wrap =
    Atd.Annot.get_field
      ~parse:(fun s -> Some (Some s))
      ~default:(default "wrap")
      ~sections:path
      ~field:"wrap"
      an
  in
  let unwrap =
    Atd.Annot.get_field
      ~parse:(fun s -> Some (Some s))
      ~default:(default "unwrap")
      ~sections:path
      ~field:"unwrap"
      an
  in
  match t, wrap, unwrap with
      None, None, None -> None
    | Some t, Some wrap, Some unwrap ->
        Some { ocaml_wrap_t = t; ocaml_wrap = wrap; ocaml_unwrap = unwrap }
    | _ ->
        Error.error loc "Incomplete annotation. Missing t, wrap or unwrap"

let get_ocaml_cons target default an =
  let path = path_of_target target in
  Atd.Annot.get_field
    ~parse:(fun s -> Some s)
    ~default
    ~sections:path
    ~field:"name"
    an

let get_ocaml_fname target default an =
  let path = path_of_target target in
  Atd.Annot.get_field
    ~parse:(fun s -> Some s)
    ~default:default
    ~sections:path
    ~field:"name"
    an

let get_ocaml_default target an =
  let path = path_of_target target in
  Atd.Annot.get_opt_field
    ~parse:(fun s -> Some s)
    ~sections:path
    ~field:"default"
    an

let get_ocaml_mutable target an =
  let path = path_of_target target in
  Atd.Annot.get_flag
    ~sections:path
    ~field:"mutable"
    an

let get_ocaml_predef target an =
  let path = path_of_target target in
  Atd.Annot.get_flag
    ~sections:path
    ~field:"predef"
    an

let get_ocaml_module target an =
  let path = path_of_target target in
  let o =
    Atd.Annot.get_opt_field
      ~parse:(fun s -> Some s)
      ~sections:path
      ~field:"module"
      an
  in
  match o with
    Some s -> Some (s, s)
  | None ->
      Atd.Annot.get_opt_field
        ~parse:(fun s -> Some s)
        ~sections:path
        ~field:"from" an
      |> Option.map (fun s ->
        let type_module = s ^ "_t" in
        let main_module =
          match target with
          | Default -> type_module
          | Biniou -> s ^ "_b"
          | Json -> s ^ "_j"
          | Bucklescript -> s ^ "_bs"
          | Validate -> s ^ "_v"
        in
        (type_module, main_module))

let get_ocaml_t target default an =
  let path = path_of_target target in
  Atd.Annot.get_field
    ~parse:(fun s -> Some s)
    ~default:default
    ~sections:path
    ~field:"t"
    an

let get_ocaml_module_and_t target default_name an =
  get_ocaml_module target an
  |> Option.map (fun (type_module, main_module) ->
  (type_module, main_module, get_ocaml_t target default_name an))


(*
  OCaml syntax tree
*)
type ocaml_type_param = string list

type ocaml_expr =
    [ `Sum of (atd_ocaml_sum * ocaml_variant list)
    | `Record of (atd_ocaml_record * ocaml_field list)
    | `Tuple of ocaml_expr list
    | `Name of (string * ocaml_expr list)
    | `Tvar of string
    ]

and ocaml_variant =
    string * ocaml_expr option * Atd.Doc.doc option

and ocaml_field =
    (string * bool (* is mutable? *)) * ocaml_expr * Atd.Doc.doc option

type ocaml_def = {
  o_def_name : (string * ocaml_type_param);
  o_def_alias : (string * ocaml_type_param) option;
  o_def_expr : ocaml_expr option;
  o_def_doc : Atd.Doc.doc option
}

type ocaml_module_item =
    [ `Type of ocaml_def ]

type ocaml_module_body = ocaml_module_item list



(*
  Mapping from ATD to OCaml
*)

let rec map_expr target
    (type_param: type_param) (x : type_expr) : ocaml_expr =
  match x with
    Atd.Ast.Sum (_, l, an) ->
      let kind = get_ocaml_sum target an in
      `Sum (kind, List.map (map_variant target) l)
  | Record (loc, l, an) ->
      let kind = get_ocaml_record target an in
      let field_prefix = get_ocaml_field_prefix target an in
      if l = [] then
        Error.error loc "Empty record (not valid in OCaml)"
      else
        `Record (kind, List.map (map_field target field_prefix) l)
  | Tuple (_, l, _) ->
      `Tuple (List.map (fun (_, x, _) -> (map_expr target []) x) l)
  | List (_, x, an) ->
      let s = string_of_ocaml_list (get_ocaml_list target an) in
      `Name (s, [map_expr target [] x])
  | Option (_, x, _) ->
      `Name ("option", [map_expr target [] x])
  | Nullable (_, x, _) ->
      `Name ("option", [map_expr target [] x])
  | Shared (_, _, _) ->
      failwith "Sharing is not supported"
  | Wrap (loc, x, a) ->
      (match get_ocaml_wrap ~type_param target loc a with
         None -> map_expr target [] x
       | Some { ocaml_wrap_t ; _ } -> `Name (ocaml_wrap_t, [])
      )
  | Name (_, (_2, s, l), an) ->
      let s = get_ocaml_type_path target s an in
      `Name (s, List.map (map_expr target []) l)
  | Tvar (_, s) ->
      `Tvar s

and map_variant target (x : variant) : ocaml_variant =
  match x with
    Inherit _ -> assert false
  | Variant (loc, (s, an), o) ->
      let s = get_ocaml_cons target s an in
      (s, Option.map (map_expr target []) o, Atd.Doc.get_doc loc an)

and map_field target ocaml_field_prefix (x : field) : ocaml_field =
  match x with
    `Inherit _ -> assert false
  | `Field (loc, (atd_fname, _, an), x) ->
      let ocaml_fname =
        get_ocaml_fname target (ocaml_field_prefix ^ atd_fname) an in
      let fname =
        if ocaml_fname = atd_fname then ocaml_fname
        else sprintf "%s (*atd %s *)" ocaml_fname atd_fname
      in
      let is_mutable = get_ocaml_mutable target an in
      ((fname, is_mutable), map_expr target [] x, Atd.Doc.get_doc loc an)

let map_def
    ~(target : target)
    ~(type_aliases : string option)
    ((loc, (s, param, an1), x) : type_def) : ocaml_def option =
  let is_predef = get_ocaml_predef target an1 in
  let is_abstract = Mapping.is_abstract x in
  let define_alias =
    if is_predef || is_abstract || type_aliases <> None then
      match get_ocaml_module_and_t target s an1, type_aliases with
          Some (types_module, _, s), _ -> Some (types_module, s)
        | None, Some types_module -> Some (types_module, s)

        | None, None -> None
    else
      None
  in
  if is_predef && define_alias = None then
    None
  else
    let an2 = Atd.Ast.annot_of_type_expr x in
    let an = an1 @ an2 in
    let doc = Atd.Doc.get_doc loc an in
    let alias, x =
      match define_alias with
          None ->
            if is_abstract then (None, None)
            else (None, Some (map_expr target param x))
        | Some (module_path, ext_name) ->
            let alias = Some (module_path ^ "." ^ ext_name, param) in
            let x =
              match map_expr target param x with
                  `Sum (Classic, _)
                | `Record (Record, _) as x -> Some x
                | _ -> None
            in
            (alias, x)
    in
    if x = None && alias = None then
      None
    else
      Some {
        o_def_name = (s, param);
        o_def_alias = alias;
        o_def_expr = x;
        o_def_doc = doc
      }


let map_module ~target ~type_aliases (l : module_body) : ocaml_module_body =
  List.filter_map (
    fun (Atd.Ast.Type td) ->
      Option.map (fun x -> `Type x) (map_def ~target ~type_aliases td)
  ) l


(*
  Mapping from Mapping to OCaml
*)


let rec ocaml_of_expr_mapping (x : (Repr.t, _) mapping) : ocaml_expr =
  match x with
    Unit (_, Unit, _) -> `Name ("unit", [])
  | Bool (_, Bool, _) -> `Name ("bool", [])
  | Int (_, Int x, _) -> `Name (string_of_ocaml_int x, [])
  | Float (_, Float, _) -> `Name ("float", [])
  | String (_, String, _) -> `Name ("string", [])
  | Sum (_, a, Sum kind, _) ->
      let l = Array.to_list a in
      `Sum (kind, List.map ocaml_of_variant_mapping l)
  | Record (_, a, Record _, _) ->
      let l = Array.to_list a in
      `Record (Record, List.map ocaml_of_field_mapping l)
  | Tuple (_, a, _, _) ->
      let l = Array.to_list a in
      `Tuple (List.map (fun x -> ocaml_of_expr_mapping x.cel_value) l)
  | List (_, x, List kind, _) ->
      `Name (string_of_ocaml_list kind, [ocaml_of_expr_mapping x])
  | Option (_, x, Option, _) ->
      `Name ("option", [ocaml_of_expr_mapping x])
  | Nullable (_, x, Nullable, _) ->
      `Name ("option", [ocaml_of_expr_mapping x])
  | Wrap _ ->
      assert false
  | Name (_, s, l, _, _) ->
      `Name (s, List.map ocaml_of_expr_mapping l)
  | Tvar (_, s) ->
      `Tvar s
  | _ -> assert false

and ocaml_of_variant_mapping x =
  let o =
    match x.var_arepr with
        Variant o -> o
      | _ -> assert false
  in
  (o.ocaml_cons, Option.map ocaml_of_expr_mapping x.var_arg, o.ocaml_vdoc)

and ocaml_of_field_mapping x =
  let o =
    match x.f_arepr with
        Field o -> o
      | _ -> assert false
  in
  let v = ocaml_of_expr_mapping x.f_value in
  ((o.ocaml_fname, o.ocaml_mutable), v, o.ocaml_fdoc)


(*
  Pretty-printing
*)



let rlist = { list with
                wrap_body = `Force_breaks;
                indent_body = 0;
                align_closing = false;
                space_after_opening = false;
                space_before_closing = false
            }

let plist = { list with
                align_closing = false;
                space_after_opening = false;
                space_before_closing = false }

let hlist = { list with wrap_body = `No_breaks }
let shlist = { hlist with
                 stick_to_label = false;
                 space_after_opening = false;
                 space_before_closing = false }

let llist = {
  list with
    separators_stick_left = false;
    space_before_separator = true;
    space_after_separator = true
}

let lplist = {
  llist with
    space_after_opening = false;
    space_before_closing = false
}

let vlist1 = { list with stick_to_label = false }

let vlist = {
  vlist1 with
    wrap_body = `Force_breaks;
}


let make_atom s = Atom (s, atom)

let horizontal_sequence l = Easy_format.List (("", "", "", shlist), l)

let vertical_sequence ?(skip_lines = 0) l =
  let l =
    if skip_lines = 0 then l
    else
      let sep = List.init skip_lines (fun _ -> (Atom ("", atom))) in
      List.insert_sep l ~sep
  in
  Easy_format.List (("", "", "", rlist), l)

let escape f s =
  let buf = Buffer.create (2 * String.length s) in
  for i = 0 to String.length s - 1 do
    let c = s.[i] in
    match f c with
        None -> Buffer.add_char buf c
      | Some s -> Buffer.add_string buf s
  done;
  Buffer.contents buf

let ocamldoc_escape s =
  let esc = function
      '{' | '}' | '[' | ']' | '@' | '\\' as c -> Some (sprintf "\\%c" c)
    | _ -> None
  in
  escape esc s

let ocamldoc_verbatim_escape s =
  let esc = function
      '{' | '}' | '\\' as c -> Some (sprintf "\\%c" c)
    | _ -> None
  in
  escape esc s

let split = Re.Str.split (Re.Str.regexp " ")


let make_ocamldoc_block = function
  | Atd.Doc.Pre s -> Atom ("\n{v\n" ^ ocamldoc_verbatim_escape s ^ "\nv}", atom)
  | Paragraph l ->
      let l = List.map (function
        | Atd.Doc.Text s -> ocamldoc_escape s
        | Code s -> "[" ^ ocamldoc_escape s ^ "]"
      ) l
      in
      let words = split (String.concat "" l) in
      let atoms = List.map (fun s -> Atom (s, atom)) words in
      List (("", "", "", plist), atoms)

let rec make_ocamldoc_blocks = function
  | []
  | [_] as l -> List.map make_ocamldoc_block l
  | x :: (y :: _ as xs) ->
      let rest = make_ocamldoc_blocks xs in
      let rest =
        match y with
        | Atd.Doc.Paragraph _ -> Atom ("", atom) :: rest
        | Pre _ -> rest in
      make_ocamldoc_block x :: rest

let make_ocamldoc_comment l =
  let blocks = make_ocamldoc_blocks l in
  let xlist =
    match l with
      [] | [_] -> vlist1
    | _ -> vlist
  in
  Easy_format.List (("(**", "", "*)", xlist), blocks)

let prepend_ocamldoc_comment doc x =
  match doc with
      None -> x
    | Some y ->
        let comment = make_ocamldoc_comment y in
        Easy_format.List (("", "", "", rlist), [comment;x])

let append_ocamldoc_comment x doc =
  match doc with
      None -> x
    | Some y ->
        let comment = make_ocamldoc_comment y in
        Label ((x, label), comment)

let format_pp_conv_node node = function
  | Camlp4 []
  | Ppx [] -> node
  | converters ->
    let converters =
      match converters with
      | Ppx cs -> "[@@deriving " ^ (String.concat ", " cs) ^ "]"
      | Camlp4 cs -> "with " ^ (String.concat ", " cs) in
    Label ((node, label), make_atom converters)

let rec format_module_item pp_convs
    is_first (`Type def : ocaml_module_item) =
  let type_ = if is_first then "type" else "and" in
  let s, param = def.o_def_name in
  let alias = def.o_def_alias in
  let expr = def.o_def_expr in
  let doc = def.o_def_doc in
  let append_if b s1 s2 =
    if b then s1 ^ s2
    else s1
  in
  let part1 =
    horizontal_sequence (
      make_atom type_ ::
        prepend_type_param param
        [ make_atom (append_if (alias <> None || expr <> None) s " =") ]
    )
  in
  let part12 =
    match alias with
        None -> part1
      | Some (name, param) ->
          let right =
            horizontal_sequence (
              prepend_type_param param
                [ make_atom (append_if (expr <> None) name " =") ]
            )
          in
          Label (
            (part1, label),
            right
          )
  in
  let part123 =
    match expr with
        None -> part12

      | Some t ->
          Label (
            (part12, label),
            format_type_expr t
          )
  in
  format_pp_conv_node (prepend_ocamldoc_comment doc part123) pp_convs


and prepend_type_param l tl =
  match l with
      [] -> tl
    | _ ->
        let make_var s = make_atom ("'" ^ s) in
        let x =
          match l with
              [s] -> make_var s
            | l -> List (("(", ",", ")", plist), List.map make_var l)
        in
        x :: tl

and prepend_type_args l tl =
  match l with
      [] -> tl
    | _ ->
        let x =
          match l with
              [t] -> format_type_expr t
            | l -> List (("(", ",", ")", plist), List.map format_type_expr l)
        in
        x :: tl

and format_type_expr x =
  match x with
      `Sum (kind, l) ->
        let op, cl =
          match kind with
              Classic -> "", ""
            | Poly -> "[", "]"
        in
        List (
            (op, "|", cl, llist),
            List.map (format_variant kind) l
          )
    | `Record (kind, l) ->
        let op, cl =
          match kind with
              Record -> "{", "}"
            | Object -> "<", ">"
        in
        List (
          (op, ";", cl, list),
          List.map format_field l
        )
    | `Tuple l ->
        List (
          ("(", "*", ")", lplist),
          List.map format_type_expr l
        )
    | `Name (name, args) ->
        format_type_name name args

    | `Tvar name ->
        make_atom ("'" ^ name)

and format_type_name name args =
  horizontal_sequence (prepend_type_args args [ make_atom name ])

and format_field ((s, is_mutable), t, doc) =
  let l =
    let l = [make_atom (s ^ ":")] in
    if is_mutable then
      make_atom "mutable" :: l
    else l
  in
  let field =
    Label (
      (horizontal_sequence l, label),
      format_type_expr t
    )
  in
  append_ocamldoc_comment field doc

and format_variant kind (s, o, doc) =
  let s = tick kind ^ s in
  let cons = make_atom s in
  let variant =
    match o with
        None -> cons
      | Some t ->
          Label (
            (cons, label),
            Label (
              (make_atom "of", label),
              format_type_expr t
            )
          )
  in
  append_ocamldoc_comment variant doc

let format_module_items pp_convs (l : ocaml_module_body) =
  match l with
      x :: l ->
        format_module_item pp_convs true x ::
          List.map (fun x -> format_module_item pp_convs false x) l
    | [] -> []

let format_module_bodies pp_conv (l : (bool * ocaml_module_body) list) =
  List.concat_map (fun (_, x) -> format_module_items pp_conv x) l

let format_head (loc, an) =
  match Atd.Doc.get_doc loc an with
      None -> []
    | Some doc -> [make_ocamldoc_comment doc]

let format_all l =
  vertical_sequence ~skip_lines:1 l


let ocaml_of_expr x : string =
  Easy_format.Pretty.to_string (format_type_expr x)

let ocaml_of_atd ?(pp_convs=Ppx []) ~target ~type_aliases
    (head, (l : (bool * module_body) list)) : string =
  let head = format_head head in
  let bodies =
    List.map (fun (is_rec, m) ->
                (is_rec, map_module ~target ~type_aliases m)) l
  in
  let body = format_module_bodies pp_convs bodies in
  let x = format_all (head @ body) in
  Easy_format.Pretty.to_string x

let unwrap_option = function
  | Option (_, x, _, _)
  | Nullable (_, x, _, _) -> x
  | Name (loc, s, _, _, _) ->
      Error.error loc ("Not an option type: " ^ s)
  | x ->
      Error.error (loc_of_mapping x) "Not an option type"


let get_implicit_ocaml_default = function
  | Unit (_, Repr.Unit, _) -> Some "()"
  | Bool (_, Bool, _) -> Some "false"
  | Int (_, Int o, _) ->
      Some (match o with
          Int -> "0"
        | Char -> "'\000'"
        | Int32 -> "0l"
        | Int64 -> "0L"
        | Float -> "0.")
  | Float (_, Float, _) -> Some "0.0"
  | String (_, String, _) -> Some "\"\""
  | List (_, _, List List, _) -> Some "[]"
  | List (_, _, List Array, _) -> Some "[||]"
  | Option (_, _, Option, _) -> Some "None"
  | Nullable (_, _, Nullable, _) -> Some "None"
  | _ -> None

type create_fields =
  { intf_params: string
  ; impl_params: string
  ; impl_fields: string
  }

let map_record_creator_field deref x =
  let o =
    match x.f_arepr with
        Repr.Field o -> o
      | _ -> assert false
  in
  let fname = o.ocaml_fname in
  let impl2 = sprintf "\n    %s = %s;" fname fname in
  match x.f_kind with
      Required ->
        let t = ocaml_of_expr (ocaml_of_expr_mapping x.f_value) in
        let intf = sprintf "\n  %s: %s ->" fname t in
        let impl1 = sprintf "\n  ~%s" fname in
        { intf_params = intf
        ; impl_params = impl1
        ; impl_fields = impl2
        }

    | Optional ->
        let x = unwrap_option (deref x.f_value) in
        let t = ocaml_of_expr (ocaml_of_expr_mapping x) in
        let intf = sprintf "\n  ?%s: %s ->" fname t in
        let impl1 = sprintf "\n  ?%s" fname in
        { intf_params = intf
        ; impl_params = impl1
        ; impl_fields = impl2
        }

    | With_default ->
        let t = ocaml_of_expr (ocaml_of_expr_mapping x.f_value) in
        let intf = sprintf "\n  ?%s: %s ->" fname t in
        let impl1 =
          let default =
            match o.ocaml_default with
                None ->
                  (match get_implicit_ocaml_default (deref x.f_value) with
                       None ->
                         Error.error x.f_loc "Missing default field value"
                     | Some s -> s
                  )
              | Some s -> s
          in
          sprintf "\n  ?(%s = %s)" fname default
        in
        { intf_params = intf
        ; impl_params = impl1
        ; impl_fields = impl2
        }

let obj_unimplemented loc = function
   | Record -> ()
   | Object -> Error.error loc "Sorry, OCaml objects are not supported"
atd-2.1.0/atdgen/src/ocaml.mli000066400000000000000000000056631357165332000161300ustar00rootroot00000000000000(** OCaml-specific options derived from ATD annotations. *)

type pp_convs =
  | Camlp4 of string list
  | Ppx of string list

type atd_ocaml_sum = Classic | Poly
type atd_ocaml_record = Record | Object
type atd_ocaml_int = Int | Char | Int32 | Int64 | Float
type atd_ocaml_list = List | Array
type target = Default | Biniou | Json | Validate | Bucklescript

type atd_ocaml_wrap = {
  ocaml_wrap_t : string;
  ocaml_wrap : string;
  ocaml_unwrap : string;
}

type atd_ocaml_field = {
  ocaml_default : string option;
  ocaml_fname : string;
  ocaml_mutable : bool;
  ocaml_fdoc : Atd.Doc.doc option;
}

type atd_ocaml_variant = {
  ocaml_cons : string;
  ocaml_vdoc : Atd.Doc.doc option;
}

type atd_ocaml_def = {
  ocaml_predef : bool;
  ocaml_ddoc : Atd.Doc.doc option;
}

module Repr : sig
  (** OCaml-specific options that decorate each kind of ATD AST node. *)
  type t =
    | Unit
    | Bool
    | Int of atd_ocaml_int
    | Float
    | String
    | Sum of atd_ocaml_sum
    | Record of atd_ocaml_record
    | Tuple
    | List of atd_ocaml_list
    | Option
    | Nullable
    | Wrap of atd_ocaml_wrap option
    | Name of string
    | External of (string * string * string)
        (*
          (module providing the type,
           module providing everything else,
           type name)
        *)

    | Cell of atd_ocaml_field
    | Field of atd_ocaml_field
    | Variant of atd_ocaml_variant
    | Def of atd_ocaml_def
end

val get_ocaml_sum : target -> Atd.Annot.t -> atd_ocaml_sum
val get_ocaml_record : target -> Atd.Annot.t -> atd_ocaml_record
val get_ocaml_field_prefix : target -> Atd.Annot.t -> string
val get_ocaml_list : target -> Atd.Annot.t -> atd_ocaml_list
val get_ocaml_wrap : type_param:string list -> target -> Atd.Ast.loc ->
  Atd.Annot.t -> atd_ocaml_wrap option
val get_ocaml_int : target -> Atd.Annot.t -> atd_ocaml_int
val get_ocaml_default : target -> Atd.Annot.t -> string option
val get_ocaml_cons : target -> string -> Atd.Annot.t -> string
val get_ocaml_fname : target -> string -> Atd.Annot.t -> string
val get_ocaml_mutable : target -> Atd.Annot.t -> bool
val get_ocaml_predef : target -> Atd.Annot.t -> bool

val get_ocaml_module_and_t
  : target
  -> string
  -> Atd.Annot.t
  -> (string * string * string) option


val get_implicit_ocaml_default
  : (Repr.t, 'b) Mapping.mapping
  -> string option

val unwrap_option
  :  ('b, 'c) Mapping.mapping
  -> ('b, 'c) Mapping.mapping

val ocaml_of_atd
  : ?pp_convs:pp_convs
  -> target:target
  -> type_aliases:string option
  -> (Atd.Ast.loc * Atd.Ast.annot) * (bool * Atd.Ast.module_body) list
  -> string

type create_fields =
  { intf_params: string
  ; impl_params: string
  ; impl_fields: string
  }

val map_record_creator_field
  : ((Repr.t, 'a) Mapping.mapping
     -> (Repr.t, 'b) Mapping.mapping)
  -> (Repr.t, 'a) Mapping.field_mapping
  -> create_fields

val tick : atd_ocaml_sum -> string

val dot : atd_ocaml_record -> string

val obj_unimplemented : Atd.Ast.loc -> atd_ocaml_record -> unit
atd-2.1.0/atdgen/src/oj_emit.ml000066400000000000000000001137441357165332000163120ustar00rootroot00000000000000(*
  OCaml code generator for the json format.
*)


open Atd.Import
open Indent

open Atd.Ast
open Mapping

let target : Ocaml.target = Json

(*
  OCaml code generator (json readers and writers)
*)

type param = {
  deref : (Ocaml.Repr.t, Json.json_repr) Mapping.mapping ->
    (Ocaml.Repr.t, Json.json_repr) Mapping.mapping;
  std : bool;
  unknown_field_handler : string option;
  (* Optional handler that takes a field name as argument
     and does something with it such as displaying a warning message. *)

  force_defaults : bool;

  preprocess_input : string option;
  (* intended for UTF-8 validation *)

  ocaml_version: (int * int) option;

}

let make_ocaml_json_intf ~with_create buf deref defs =
  List.concat_map snd defs
  |> List.filter Ox_emit.include_intf
  |> List.iter (fun x ->
    let s = x.def_name in
    let full_name = Ox_emit.get_full_type_name x in
    let writer_params =
      String.concat "" (
        List.map
          (fun s -> sprintf "\n  (Bi_outbuf.t -> '%s -> unit) ->" s)
          x.def_param
      )
    in
    let reader_params =
      String.concat "" (
        List.map
          (fun s ->
             sprintf "\n  (Yojson.Safe.lexer_state -> \
                      Lexing.lexbuf -> '%s) ->" s)
          x.def_param
      )
    in
    bprintf buf "\
val write_%s :%s
  Bi_outbuf.t -> %s -> unit
  (** Output a JSON value of type {!%s}. *)

"
      s writer_params
      full_name
      s;

    bprintf buf "\
val string_of_%s :%s
  ?len:int -> %s -> string
  (** Serialize a value of type {!%s}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

"
      s writer_params
      full_name
      s;

    bprintf buf "\
val read_%s :%s
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> %s
  (** Input JSON data of type {!%s}. *)

"
      s reader_params
      full_name
      s;

    bprintf buf "\
val %s_of_string :%s
  string -> %s
  (** Deserialize JSON data of type {!%s}. *)

"
      s reader_params
      full_name
      s;
    Ox_emit.maybe_write_creator_intf ~with_create deref buf x
  )

let insert sep l =
  let rec ins sep = function
      [] -> []
    | x :: l -> sep :: x :: ins sep l
  in
  match l with
    [] -> []
  | x :: l -> x :: ins sep l

let make_json_string s = Yojson.Safe.to_string (`String s)

(*
  ('a, 'b) t            -> write_t write__a write__b
  ('a, foo) t           -> write_t write__a write_foo
  ('a, (foo, 'b) bar) t -> write_t write__a (write_bar write_foo write__b)
*)
let rec get_writer_name
    ?(paren = false)
    ?(name_f = fun s -> "write_" ^ s)
    p (x : Oj_mapping.t) : string =
  match x with
    Unit (_, Ocaml.Repr.Unit, Unit) ->
      "Yojson.Safe.write_null"
  | Bool (_, Bool, Bool) ->
      "Yojson.Safe.write_bool"
  | Int (_, Int o, Int) ->
      (match o with
         Int -> "Yojson.Safe.write_int"
       | Char ->  "Atdgen_runtime.Oj_run.write_int8"
       | Int32 -> "Atdgen_runtime.Oj_run.write_int32"
       | Int64 -> "Atdgen_runtime.Oj_run.write_int64"
       | Float -> "Atdgen_runtime.Oj_run.write_float_as_int"
      )

  | Float (_, Float, Float j) ->
      (match j with
         Float None ->
           if p.std then "Yojson.Safe.write_std_float"
           else "Yojson.Safe.write_float"
       | Float (Some precision) ->
           if p.std then
             sprintf "Yojson.Safe.write_std_float_prec %i" precision
           else
             sprintf "Yojson.Safe.write_float_prec %i" precision
       | Int ->
           "Atdgen_runtime.Oj_run.write_float_as_int"
      )

  | String (_, String, String) ->
      "Yojson.Safe.write_string"

  | Tvar (_, s) -> "write_" ^ (Ox_emit.name_of_var s)

  | Name (_, s, args, None, None) ->
      let l = List.map (get_writer_name ~paren:true p) args in
      let s = String.concat " " (name_f s :: l) in
      if paren && l <> [] then "(" ^ s ^ ")"
      else s

  | External (_, _, args,
              External (_, main_module, ext_name),
              External) ->
      let f = main_module ^ "." ^ name_f ext_name in
      let l = List.map (get_writer_name ~paren:true p) args in
      let s = String.concat " " (f :: l) in
      if paren && l <> [] then "(" ^ s ^ ")"
      else s

  | _ -> assert false


let get_left_writer_name p name param =
  let args = List.map (fun s -> Tvar (dummy_loc, s)) param in
  get_writer_name p (Name (dummy_loc, name, args, None, None))

let get_left_to_string_name p name param =
  let name_f s = "string_of_" ^ s in
  let args = List.map (fun s -> Tvar (dummy_loc, s)) param in
  get_writer_name ~name_f p (Name (dummy_loc, name, args, None, None))


let rec get_reader_name
    ?(paren = false)
    ?(name_f = fun s -> "read_" ^ s)
    p (x : Oj_mapping.t) : string =

  match x with
    Unit (_, Unit, Unit) -> "Atdgen_runtime.Oj_run.read_null"
  | Bool (_, Bool, Bool) -> "Atdgen_runtime.Oj_run.read_bool"
  | Int (_, Int o, Int) ->
      (match o with
         Int -> "Atdgen_runtime.Oj_run.read_int"
       | Char -> "Atdgen_runtime.Oj_run.read_int8"
       | Int32 -> "Atdgen_runtime.Oj_run.read_int32"
       | Int64 -> "Atdgen_runtime.Oj_run.read_int64"
       | Float -> "Atdgen_runtime.Oj_run.read_number"
      )

  | Float (_, Float, Float _) -> "Atdgen_runtime.Oj_run.read_number"

  | String (_, String, String) -> "Atdgen_runtime.Oj_run.read_string"

  | Tvar (_, s) -> "read_" ^ Ox_emit.name_of_var s

  | Name (_, s, args, None, None) ->
      let l = List.map (get_reader_name ~paren:true p) args in
      let s = String.concat " " (name_f s :: l) in
      if paren && l <> [] then "(" ^ s ^ ")"
      else s

  | External (_, _, args,
              External (_, main_module, ext_name),
              External) ->
      let f = main_module ^ "." ^ name_f ext_name in
      let l = List.map (get_reader_name ~paren:true p) args in
      let s = String.concat " " (f :: l) in
      if paren && l <> [] then "(" ^ s ^ ")"
      else s

  | _ -> assert false


let get_left_reader_name p name param =
  let args = List.map (fun s -> Tvar (dummy_loc, s)) param in
  get_reader_name p (Name (dummy_loc, name, args, None, None))

let get_left_of_string_name p name param =
  let name_f s = s ^ "_of_string" in
  let args = List.map (fun s -> Tvar (dummy_loc, s)) param in
  get_reader_name ~name_f p (Name (dummy_loc, name, args, None, None))

let write_with_adapter adapter writer =
  match adapter.Json.ocaml_adapter with
  | None -> writer
  | Some adapter_path ->
      let restore =
        Oj_mapping.json_restorer_of_adapter_path adapter_path in
      [
        Line (
          sprintf "Atdgen_runtime.Oj_run.write_with_adapter %s (" restore
        );
        Block writer;
        Line ")";
      ]

let unwrap_f_value { Ox_emit.mapping; unwrapped; _} (p : param) =
  if unwrapped then
    Ocaml.unwrap_option (p.deref mapping.f_value)
  else
    mapping.f_value

let rec make_writer ?type_constraint p (x : Oj_mapping.t) : Indent.t list =
  match x with
    Unit _
  | Bool _
  | Int _
  | Float _
  | String _
  | Name _
  | External _
  | Tvar _ -> [ Line (get_writer_name p x) ]

  | Sum (_, a, Sum o, Sum j) ->
      let tick = Ocaml.tick o in
      let open_enum = j.Json.json_open_enum in
      let body : Indent.t list =
        [
          Line "match x with";
          Block (
            Array.to_list (
              Array.map
                (fun x -> Inline (make_variant_writer p ~tick ~open_enum x))
                a
            )
          )
        ]
      in
      let standard_writer = [
        Annot ("fun", Line "fun ob x ->");
        Block body
      ] in
      let adapter = j.json_sum_adapter in
      write_with_adapter adapter standard_writer

  | Record (_, a, Record o, Record j) ->
      let xval =
        match type_constraint with
        | Some x -> sprintf "(x : %s)" x
        | None -> "x"
      in
      let standard_writer = [
        Annot ("fun", Line (sprintf "fun ob %s ->" xval));
        Block (make_record_writer p a o);
      ] in
      let adapter = j.json_record_adapter in
      write_with_adapter adapter standard_writer

  | Tuple (_, a, Tuple, Tuple) ->
      let len = Array.length a in
      let a =
        Array.mapi (
          fun i x ->
            Inline [
              Line (sprintf "(let %s = x in" (Ox_emit.nth "x" i len));
              Line "(";
              Block (make_writer p x.cel_value);
              Line ") ob x";
              Line ");"
            ]
        ) a
      in
      let l =
        insert (Line "Bi_outbuf.add_char ob ',';") (Array.to_list a)
      in
      let op, cl =
        if p.std then '[', ']'
        else '(', ')'
      in
      [
        Annot ("fun", Line "fun ob x ->");
        Block [
          Line (sprintf "Bi_outbuf.add_char ob %C;" op);
          Inline l;
          Line (sprintf "Bi_outbuf.add_char ob %C;" cl);
        ]
      ]

  | List (loc, x, List o, List j) ->
      (match j with
         Array ->
           let write =
             match o with
               List -> "Atdgen_runtime.Oj_run.write_list ("
             | Array -> "Atdgen_runtime.Oj_run.write_array ("
           in
           [
             Line write;
             Block (make_writer p x);
             Line ")";
           ]

       | Object ->
           let k, v = Ox_emit.get_assoc_type p.deref loc x in
           let write =
             match o with
               List -> "Atdgen_runtime.Oj_run.write_assoc_list ("
             | Array -> "Atdgen_runtime.Oj_run.write_assoc_array ("
           in
           [
             Line write;
             Block (make_writer p k);
             Line ") (";
             Block (make_writer p v);
             Line ")";
           ]
      )

  | Option (_, x, Option, Option) ->
      [
        Line (sprintf "Atdgen_runtime.Oj_run.write_%soption ("
                (if p.std then "std_" else ""));
        Block (make_writer p x);
        Line ")";
      ]

  | Nullable (_, x, Nullable, Nullable) ->
      [
        Line "Atdgen_runtime.Oj_run.write_nullable (";
        Block (make_writer p x);
        Line ")";
      ]

  | Wrap (_, x, Wrap o, Wrap) ->
      (match o with
         None -> make_writer p x
       | Some { Ocaml.ocaml_unwrap; _} ->
           [
             Line "fun ob x -> (";
             Block [
               Line (sprintf "let x = ( %s ) x in (" ocaml_unwrap);
               Block (make_writer p x);
               Line ") ob x)";
             ]
           ]
      )

  | _ -> assert false


and make_variant_writer p ~tick ~open_enum x : Indent.t list =
  let o, j =
    match x.var_arepr, x.var_brepr with
      Variant o, Variant j -> o, j
    | _ -> assert false
  in
  let ocaml_cons = o.Ocaml.ocaml_cons in
  let json_cons = j.Json.json_cons in
  match x.var_arg with
  | None ->
      let enclose s =
        if p.std then s
        else "<" ^ s ^ ">"
      in
      [
        Line (sprintf "| %s%s -> Bi_outbuf.add_string ob %S"
                tick ocaml_cons
                (enclose (make_json_string json_cons)))
      ]
  | Some v when open_enum ->
      (* v should resolve to type string. *)
      [
        Line (sprintf "| %s%s x -> (" tick ocaml_cons);
        Block [
          Block (make_writer p v);
          Line ") ob x;";
        ];
      ]
  | Some v ->
      let op, sep, cl =
        if p.std then "[", ",", ']'
        else "<", ":", '>'
      in
      [
        Line (sprintf "| %s%s x ->" tick ocaml_cons);
        Block [
          Line (sprintf "Bi_outbuf.add_string ob %S;"
                  (op ^ make_json_string json_cons ^ sep));
          Line "(";
          Block (make_writer p v);
          Line ") ob x;";
          Line (sprintf "Bi_outbuf.add_char ob %C" cl);
        ]
      ]

and make_record_writer p a record_kind =
  let dot = Ocaml.dot record_kind in
  let fields = Ox_emit.get_fields p.deref a in
  let sep =
    [
      Line "if !is_first then";
      Block [
        Line "is_first := false"
      ];
      Line "else";
      Block [
        Line "Bi_outbuf.add_char ob ',';";
      ];
    ]
  in

  let write_fields =
    List.map (
      fun ({ Ox_emit.mapping ; ocaml_fname ; ocaml_default
           ; json_fname ; optional ; unwrapped } as field) ->
        let f_value = unwrap_f_value field p in
        let write_field_tag =
          sprintf "Bi_outbuf.add_string ob %S;"
            (make_json_string json_fname ^ ":")
        in
        let app v =
          [
            Inline sep;
            Line write_field_tag;
            Line "(";
            Block (make_writer p f_value);
            Line ")";
            Block [Line (sprintf "ob %s;" v)]
          ]
        in
        let v =
          if optional then
            sprintf "x.%s" ocaml_fname
          else
            sprintf "x%s%s" dot ocaml_fname
        in
        let l =
          if unwrapped then
            [
              Line (sprintf "(match %s with None -> () | Some x ->" v);
              Block (app "x");
              Line ");"
            ]
          else if optional && not p.force_defaults then
            [
              Line (sprintf "if %s <> %s then ("
                      v (Option.value_exn ocaml_default));
              Block (app v);
              Line ");"
            ]
          else
            app v
        in
        Inline l
    ) fields
  in
  [
    Line "Bi_outbuf.add_char ob '{';";
    Line "let is_first = ref true in";
    Inline write_fields;
    Line "Bi_outbuf.add_char ob '}';";
  ]

let wrap_tmp_required_value value =
  [
    Line "Some (";
    Block value;
    Line ")";
  ]

let unwrap_tmp_required_value ocaml_fname var =
  sprintf "(match !%s with Some x -> x \
           | None -> Atdgen_runtime.Oj_run.missing_field p %S)"
    var ocaml_fname

(*
   Json object fields come in an arbitrary order, so we read the fields
   from the input and keep their value in a temporary slot until we're done
   reading the object i.e. we find a closing brace '}'. At that point,
   we must have a value for each field so that we can create an OCaml
   record.

   Now ATD supports optional fields e.g. `?name: string option;`
   as well as required fields with a default e.g. `~special : bool;`.
   These two cases are handled similarly here because in each case we have
   an initial value to set the field to. For these, we generate essentially
   the following code:

     let field_x = ref default in

   For the examples above, this is:

     let field_name = ref None in     (* default value for option is None *)
     let field_special = ref false in (* default value for bool is false *)

   The third case, in which a required field has no default value such as
   `id : string;`, we don't have a default value so we resort to wrapping
   in an option, until we're done reading the whole json object.
   Once the json object has been read, we expect to have found a value for
   this field:

     let field_id = ref None in   (* no initial value *)
     ...                          (* read json input *)
     (* construct the ocaml record: *)
     {
       id = (match !field_id with None -> error ... | Some value -> value);
       ...
     }

   Note that we no longer use Obj.magic to improve performance because
   we don't have the resources to do so safely.
*)
let study_record ~ocaml_version fields =
  let field_assignments =
    List.fold_right (
      fun { Ox_emit.ocaml_fname ; ocaml_default ; optional ; _ }
        field_assignments ->
        let var = sprintf "field_%s" ocaml_fname in
        let initial_value, extract_value =
          match ocaml_default with
          | None ->
              assert (not optional);
              ("None",
               unwrap_tmp_required_value ocaml_fname var)
          | Some s ->
              (s,
               sprintf "!%s" var)
        in
        let init_tmp_field =
          Line (sprintf "let %s = ref (%s) in" var initial_value)
        in
        let create_field =
          Line (sprintf "%s = %s;" ocaml_fname extract_value)
        in
        (init_tmp_field, create_field) :: field_assignments
    ) fields []
  in
  let init_tmp_fields, create_record_fields = List.split field_assignments in
  let create_record = [ Line "{"; Block create_record_fields; Line "}" ] in
  init_tmp_fields, create_record

let read_with_adapter adapter reader =
  match adapter.Json.ocaml_adapter with
  | None -> reader
  | Some adapter_path ->
      let normalize =
        Oj_mapping.json_normalizer_of_adapter_path adapter_path in
      [
        Line (
          sprintf "Atdgen_runtime.Oj_run.read_with_adapter %s (" normalize
        );
        Block reader;
        Line ")";
      ]

let rec make_reader p type_annot (x : Oj_mapping.t) : Indent.t list =
  match x with
    Unit _
  | Bool _
  | Int _
  | Float _
  | String _
  | Name _
  | External _
  | Tvar _ -> [ Line (get_reader_name p x) ]

  | Sum (_, a, Sum o, Sum j) ->
      let tick = Ocaml.tick o in
      let open_enum = j.Json.json_open_enum in
      let l = Array.to_list a in
      let fallback_expr =
        [ Line "Atdgen_runtime.Oj_run.invalid_variant_tag p x" ]
      in
      let cases =
        make_cases_reader p type_annot
          ~tick ~open_enum ~std:false ~fallback_expr l
      in
      let l0, l1 =
        List.partition (fun x -> x.var_arg = None || open_enum) l
      in
      let cases0 =
        make_cases_reader p type_annot
          ~tick ~open_enum ~std:true ~fallback_expr l0
      in
      let cases1 =
        make_cases_reader p type_annot
          ~tick ~open_enum ~std:true ~fallback_expr l1
      in
      let read_tag =
        [
          Line "Yojson.Safe.read_space p lb;";
          Line "match Yojson.Safe.start_any_variant p lb with";
          Block [
            Line "| `Edgy_bracket -> (";
            Block [
              Block [
                Line "match Yojson.Safe.read_ident p lb with";
                Block cases;
              ];
              Line ")";
            ];
            Line "| `Double_quote -> (";
            Block [
              Block [
                Line "match Yojson.Safe.finish_string p lb with";
                Block cases0;
              ];
              Line ")";
            ];
            Line "| `Square_bracket -> (";
            Block [
              Block [
                Line "match Atdgen_runtime.Oj_run.read_string p lb with";
                Block cases1;
              ];
              Line ")";
            ];
          ];
        ]
      in
      let standard_reader = [
        Annot ("fun", Line "fun p lb ->");
        Block [
          Inline read_tag;
        ]
      ] in
      let adapter = j.json_sum_adapter in
      read_with_adapter adapter standard_reader

  | Record (loc, a, Record o, Record j) ->
      Ocaml.obj_unimplemented loc o;
      let standard_reader = [
        Annot ("fun", Line "fun p lb ->");
        Block (make_record_reader p type_annot loc a j)
      ] in
      let adapter = j.json_record_adapter in
      read_with_adapter adapter standard_reader

  | Tuple (_, a, Tuple, Tuple) ->
      [
        Annot ("fun", Line "fun p lb ->");
        Block (make_tuple_reader p a);
      ]

  | List (loc, x, List o, List j) ->
      (match j with
         Array ->
           let read =
             match o with
               List -> "Atdgen_runtime.Oj_run.read_list ("
             | Array -> "Atdgen_runtime.Oj_run.read_array ("
           in
           [
             Line read;
             Block (make_reader p None x);
             Line ")";
           ]

       | Object ->
           let k, v = Ox_emit.get_assoc_type p.deref loc x in
           let read =
             match o with
               List -> "Atdgen_runtime.Oj_run.read_assoc_list ("
             | Array -> "Atdgen_runtime.Oj_run.read_assoc_array ("
           in
           [
             Line read;
             Block (make_reader p None k);
             Line ") (";
             Block (make_reader p None v);
             Line ")";
           ]
      )

  | Option (loc, x, Option, Option) ->

      let a = [|
        {
          var_loc = loc;
          var_cons = "None";
          var_arg = None;
          var_arepr = Ocaml.Repr.Variant { Ocaml.ocaml_cons = "None";
                                           ocaml_vdoc = None };
          var_brepr = Json.Variant { Json.json_cons = "None" };
        };
        {
          var_loc = loc;
          var_cons = "Some";
          var_arg = Some x;
          var_arepr = Ocaml.Repr.Variant { Ocaml.ocaml_cons = "Some";
                                           ocaml_vdoc = None };
          var_brepr = Json.Variant { Json.json_cons = "Some" };
        };
      |]
      in
      let json_options = {
        Json.json_sum_adapter = Json.no_adapter;
        json_open_enum = false;
        json_lowercase_tags = false;
      } in
      make_reader p
        (Some "_ option")
        (Sum (loc, a, Sum Classic, Json.Sum json_options))

  | Nullable (_, x, Nullable, Nullable) ->
      [
        Line "fun p lb ->";
        Block [
          Line "Yojson.Safe.read_space p lb;";
          Line "(if Yojson.Safe.read_null_if_possible p lb then None";
          Line "else Some ((";
          Block (make_reader p None x);
          Line ") p lb) : _ option)"
        ]
      ]

  | Wrap (_, x, Wrap o, Wrap) ->
      (match o with
         None -> make_reader p type_annot x
       | Some { Ocaml.ocaml_wrap; _ } ->
           [
             Line "fun p lb ->";
             Block [
               Line "let x = (";
               Block (make_reader p type_annot x);
               Line ") p lb in";
               Line (sprintf "( %s ) x" ocaml_wrap);
             ]
           ]
      )

  | _ -> assert false

(*
   Return a pair (optional json constructor, expression) to be converted
   into a match case.
   If the json constructor is missing, this indicates a catch-all
   pattern (_).
*)
and make_case_reader
    p type_annot ~tick ~open_enum ~std
    (x : Oj_mapping.variant_mapping) : (string option * Indent.t list) =
  let o, j =
    match x.var_arepr, x.var_brepr with
    | Variant o, Variant j -> o, j
    | _ -> assert false
  in
  let ocaml_cons = o.Ocaml.ocaml_cons in
  let json_cons = j.Json.json_cons in
  let catch_all, expr =
    match x.var_arg with
    | None ->
        let expr =
          if std then
            [
              Line (Ox_emit.opt_annot
                      type_annot (sprintf "%s%s" tick ocaml_cons));
            ]
          else
            [
              Line "Yojson.Safe.read_space p lb;";
              Line "Yojson.Safe.read_gt p lb;";
              Line (Ox_emit.opt_annot
                      type_annot (sprintf "%s%s" tick ocaml_cons));
            ]
        in
        false, expr
    | Some v when open_enum ->
        let expr = [
          Line (Ox_emit.opt_annot
                  type_annot (sprintf "%s%s x" tick ocaml_cons));
        ] in
        true, expr
    | Some v ->
        let expr =
          if std then
            [
              Line "Yojson.Safe.read_space p lb;";
              Line "Yojson.Safe.read_comma p lb;";
              Line "Yojson.Safe.read_space p lb;";
              Line "let x = (";
              Block [
                Block (make_reader p None v);
                Line ") p lb";
              ];
              Line "in";
              Line "Yojson.Safe.read_space p lb;";
              Line "Yojson.Safe.read_rbr p lb;";
              Line (Ox_emit.opt_annot
                      type_annot (sprintf "%s%s x" tick ocaml_cons));
            ]
          else
            [
              Line "Atdgen_runtime.Oj_run.read_until_field_value p lb;";
              Line "let x = (";
              Block [
                Block (make_reader p None v);
                Line ") p lb";
              ];
              Line "in";
              Line "Yojson.Safe.read_space p lb;";
              Line "Yojson.Safe.read_gt p lb;";
              Line (Ox_emit.opt_annot
                      type_annot (sprintf "%s%s x" tick ocaml_cons));
            ]
        in
        false, expr
  in
  let opt_json_cons =
    if catch_all then None
    else Some json_cons
  in
  (opt_json_cons, expr)

and make_cases_reader p type_annot ~tick ~open_enum ~std ~fallback_expr l =
  let cases =
    List.map
      (make_case_reader p type_annot ~tick ~open_enum ~std)
      l
  in
  let specific_cases, catch_alls =
    List.partition (function (None, _) -> false | _ -> true) cases
  in
  let catch_all =
    match catch_alls with
    | [] ->
        [
          Line "| x ->";
          Block fallback_expr;
        ]
    | [(_, expr)] ->
        [
          Line "| x ->";
          Block expr;
        ]
    | _ ->
        assert false
  in
  let all_cases =
    List.map (function
      | Some json_cons, expr ->
          Inline [
            Line (sprintf "| %S ->" json_cons);
            Block expr;
          ]
      | _ -> assert false
    ) specific_cases
  in
  all_cases @ catch_all

and make_record_reader p type_annot loc a json_options =
  let keep_nulls = json_options.json_keep_nulls in
  let fields = Ox_emit.get_fields p.deref a in
  let init_fields, create_record =
    study_record ~ocaml_version:p.ocaml_version fields
  in

  let read_field =
    let a = Array.of_list fields in
    let cases =
      Array.mapi (
        fun i ({ Ox_emit.mapping ; ocaml_fname ; json_fname ; optional
               ; unwrapped ; ocaml_default = _ } as field) ->
          let f_value = unwrap_f_value field p in
          let wrap l =
            if unwrapped then
              [
                Line "Some (";
                Block l;
                Line ")"
              ]
            else l
          in
          let read_value =
            [
              Line "(";
              Block (make_reader p None f_value);
              Line ") p lb";
            ]
          in
          let read_value =
            if optional then read_value
            else wrap_tmp_required_value read_value
          in
          let expr =
            [
              Line (sprintf "field_%s := (" ocaml_fname);
              Block (wrap read_value);
              Line ");";
            ]
          in
          let opt_expr =
            if optional && not keep_nulls then
              (* treat fields with null values as missing fields
                 (atdgen's default) *)
              [
                Line "if not (Yojson.Safe.read_null_if_possible p lb) \
                      then (";
                Block expr;
                Line ")"
              ]
            else
              expr
          in
          (json_fname, opt_expr)
      ) a
    in
    let int_mapping_function, int_matching =
      let error_expr1 =
        match p.unknown_field_handler with
          None -> [ Line "-1" ]
        | Some f ->
            [ Line (sprintf "(%s) %S (String.sub s pos len); -1"
                      f (Atd.Ast.string_of_loc loc)) ]
      in
      String_match.make_ocaml_int_mapping
        ~exit_with: `Expr
        ~error_expr1
        ~error_expr2: [ Line "Yojson.Safe.skip_json p lb" ]
        (Array.to_list cases)
    in
    [
      Line "Yojson.Safe.read_space p lb;";
      Line "let f =";
      Block int_mapping_function;
      Line "in";
      Line "let i = Yojson.Safe.map_ident p f lb in";
      Line "Atdgen_runtime.Oj_run.read_until_field_value p lb;";
      Line "(";
      Block int_matching;
      Line ");";
    ]
  in

  [
    Line "Yojson.Safe.read_space p lb;";
    Line "Yojson.Safe.read_lcurl p lb;";
    Inline init_fields;
    Line "try";
    Block [
      Line "Yojson.Safe.read_space p lb;";
      Line "Yojson.Safe.read_object_end lb;";
      Inline read_field;
      Line "while true do";
      Block [
        Line "Yojson.Safe.read_space p lb;";
        Line "Yojson.Safe.read_object_sep p lb;";
        Inline read_field;
      ];
      Line "done;";
      Line "assert false;";
    ];
    Line "with Yojson.End_of_object -> (";
    Block [
      Block [
        Line "(";
        Block create_record;
        Line (sprintf "%s)" (Ox_emit.insert_annot type_annot));
      ];
      Line ")";
    ];
  ]


and make_tuple_reader p a =
  let cells =
    Array.map (
      fun x ->
        match x.cel_arepr with
          Ocaml.Repr.Cell f -> x, f.Ocaml.ocaml_default
        | _ -> assert false
    ) a
  in
  let min_length =
    let n = ref (Array.length cells) in
    (try
       for i = Array.length cells - 1 downto 0 do
         let _, default = cells.(i) in
         if default = None then (
           n := i + 1;
           raise Exit
         )
       done
     with Exit -> ());
    !n
  in

  let read_cells =
    List.flatten (
      Array.to_list (
        Array.mapi (
          fun i (x, default) ->
            let read_value =
              [
                Line "(";
                Block (make_reader p None x.cel_value);
                Line ") p lb";
              ]
            in
            let get_value =
              if i < min_length - 1 then
                [
                  Line "let x =";
                  Block read_value;
                  Line "in";
                  Line "incr len;";
                  Line "Yojson.Safe.read_space p lb;";
                  Line "Yojson.Safe.read_tuple_sep2 p std_tuple lb;";
                  Line "x"
                ]
              else if i = min_length - 1 then
                [
                  Line "let x =";
                  Block read_value;
                  Line "in";
                  Line "incr len;";
                  Line "(try";
                  Block [
                    Line "Yojson.Safe.read_space p lb;";
                    Line "Yojson.Safe.read_tuple_sep2 p std_tuple lb;";
                  ];
                  Line "with Yojson.End_of_tuple -> end_of_tuple := true);";
                  Line "x"
                ]
              else
                let default_value = Option.value_exn default in
                [
                  Line (sprintf "if !end_of_tuple then (%s)" default_value);
                  Line "else (";
                  Block [
                    Line "let x = (";
                    Block read_value;
                    Line ") in";
                    Line "incr len;";
                    Line "(try";
                    Block [
                      Line "Yojson.Safe.read_space p lb;";
                      Line "Yojson.Safe.read_tuple_sep2 p std_tuple lb;";
                    ];
                    Line "with Yojson.End_of_tuple ->";
                    Block [
                      Line "end_of_tuple := true);";
                    ];
                    Line "x";
                  ];
                  Line ")";
                ]
            in
            [
              Line (sprintf "let x%i =" i);
              Block get_value;
              Line "in";
            ]
        ) cells
      )
    )
  in

  let make_tuple =
    sprintf "(%s)"
      (String.concat ", "
         (Array.to_list (Array.mapi (fun i _ -> sprintf "x%i" i) a)))
  in
  let req_fields =
    let acc = ref [] in
    for i = Array.length cells - 1 downto 0 do
      let _, default = cells.(i) in
      if default = None then
        acc := string_of_int i :: !acc
    done;
    sprintf "[ %s ]" (String.concat "; " !acc)
  in

  let finish_empty_tuple =
    if min_length = 0 then
      [
        Line "(try Yojson.Safe.read_tuple_end2 p std_tuple lb";
        Line "with Yojson.End_of_tuple -> end_of_tuple := true)";
      ]
    else []
  in

  let skip_remaining_cells =
    [
      Line "if not !end_of_tuple then (";
      Block [
        Line "try";
        Block [
          Line "while true do";
          Block [
            Line "Yojson.Safe.skip_json p lb;";
            Line "Yojson.Safe.read_space p lb;";
            Line "Yojson.Safe.read_tuple_sep2 p std_tuple lb;";
          ];
          Line "done";
        ];
        Line "with Yojson.End_of_tuple -> ()";
      ];
      Line ");"
    ]
  in

  [
    Line "Yojson.Safe.read_space p lb;";
    Line "let std_tuple = Yojson.Safe.start_any_tuple p lb in";
    Line "let len = ref 0 in";
    Line "let end_of_tuple = ref false in";
    Inline finish_empty_tuple;
    Line "(try";
    Block [
      Inline read_cells;
      Inline skip_remaining_cells;
      Line make_tuple;
    ];
    Line "with Yojson.End_of_tuple ->";
    Block [
      Line (sprintf
              "Atdgen_runtime.Oj_run.missing_tuple_fields p !len %s);"
              req_fields);
    ];
  ]

let make_ocaml_json_writer p ~original_types is_rec let1 let2 def =
  let x = Option.value_exn def.def_value in
  let name = def.def_name in
  let type_constraint = Ox_emit.get_type_constraint ~original_types def in
  let param = def.def_param in
  let write = get_left_writer_name p name param in
  let to_string = get_left_to_string_name p name param in
  let needs_annot = Ox_emit.needs_type_annot x in
  let writer_expr =
    if needs_annot
    then make_writer ~type_constraint p x
    else make_writer p x
  in
  let eta_expand = is_rec && not (Ox_emit.is_lambda writer_expr) in
  let extra_param, extra_args, type_annot =
    match eta_expand, needs_annot with
    | true, false -> " ob x", " ob x", None
    | true, true -> sprintf " ob (x : %s)" type_constraint, " ob x", None
    | false, false -> "", "", None
    | false, true -> "", "", Some (sprintf "_ -> %s -> _" type_constraint)
  in
  [
    Line (sprintf "%s %s = ("
            let1 (Ox_emit.opt_annot_def type_annot (write ^ extra_param)));
    Block (List.map Indent.strip writer_expr);
    Line (sprintf ")%s" extra_args);
    Line (sprintf "%s %s ?(len = 1024) x =" let2 to_string);
    Block [
      Line "let ob = Bi_outbuf.create len in";
      Line (sprintf "%s ob x;" write);
      Line "Bi_outbuf.contents ob"
    ]
  ]

let make_ocaml_json_reader p ~original_types is_rec let1 let2 def =
  let x = Option.value_exn def.def_value in
  let name = def.def_name in
  let type_constraint = Ox_emit.get_type_constraint ~original_types def in
  let param = def.def_param in
  let read = get_left_reader_name p name param in
  let of_string = get_left_of_string_name p name param in
  let type_annot =
    match Ox_emit.needs_type_annot x with
    | true -> Some type_constraint
    | false -> None
  in
  let reader_expr = make_reader p type_annot x in
  let eta_expand = is_rec && not (Ox_emit.is_lambda reader_expr) in
  let extra_param, extra_args =
    if eta_expand then " p lb", " p lb"
    else "", ""
  in
  let pp =
    match p.preprocess_input with
      None -> []
    | Some f -> [ Line (sprintf "let s = ( %s ) s in" f) ]
  in
  [
    Line (sprintf "%s %s%s = (" let1 read extra_param);
    Block (List.map Indent.strip reader_expr);
    Line (sprintf ")%s" extra_args);
    Line (sprintf "%s %s s =" let2 of_string);
    Block [
      Inline pp;
      Line (
        sprintf "%s (Yojson.Safe.init_lexer ()) \
                 (Lexing.from_string s)" read);
    ]
  ]


let make_ocaml_json_impl
    ~std ~unknown_field_handler
    ~with_create ~force_defaults ~preprocess_input ~original_types
    ~ocaml_version
    buf deref defs =
  let p =
    { deref
    ; std
    ; unknown_field_handler
    ; force_defaults
    ; preprocess_input
    ; ocaml_version
    } in
  defs
  |> List.concat_map (fun (is_rec, l) ->
    let l = List.filter (fun x -> x.def_value <> None) l in
    let writers =
      List.map_first (fun ~is_first def ->
        let let1, let2 = Ox_emit.get_let ~is_rec ~is_first in
        make_ocaml_json_writer p ~original_types is_rec let1 let2 def
      ) l
    in
    let readers =
      List.map_first (fun ~is_first def ->
        let let1, let2 = Ox_emit.get_let ~is_rec ~is_first in
        make_ocaml_json_reader p ~original_types is_rec let1 let2 def
      ) l
    in
    List.flatten (writers @ readers))
  |> Indent.to_buffer buf;
  Ox_emit.maybe_write_creator_impl ~with_create deref buf defs

(*
  Glue
*)

let make_mli
    ~header ~opens ~with_typedefs ~with_create ~with_fundefs
    ocaml_typedefs deref defs =
  let buf = Buffer.create 1000 in
  bprintf buf "%s\n" header;
  Ox_emit.write_opens buf opens;
  if with_typedefs then
    bprintf buf "%s\n" ocaml_typedefs;
  if with_typedefs && with_fundefs then
    bprintf buf "\n";
  if with_fundefs then
    make_ocaml_json_intf ~with_create buf deref defs;
  Buffer.contents buf

let make_ml
    ~header ~opens ~with_typedefs ~with_create ~with_fundefs
    ~std ~unknown_field_handler
    ~force_defaults ~preprocess_input ~original_types
    ~ocaml_version
    ocaml_typedefs deref defs =
  let buf = Buffer.create 1000 in
  bprintf buf "%s\n" header;
  Ox_emit.write_opens buf opens;
  if with_typedefs then
    bprintf buf "%s\n" ocaml_typedefs;
  if with_typedefs && with_fundefs then
    bprintf buf "\n";
  if with_fundefs then
    make_ocaml_json_impl
      ~std ~unknown_field_handler
      ~with_create ~force_defaults ~preprocess_input ~original_types
      ~ocaml_version
      buf deref defs;
  Buffer.contents buf

let make_ocaml_files
    ~opens
    ~with_typedefs
    ~with_create
    ~with_fundefs
    ~all_rec
    ~std
    ~unknown_field_handler
    ~pos_fname
    ~pos_lnum
    ~type_aliases
    ~force_defaults
    ~preprocess_input
    ~ocaml_version
    ~pp_convs
    atd_file out =
  let ((head, m0), _) =
    match atd_file with
      Some file ->
        Atd.Util.load_file
          ~expand:false ~inherit_fields:true ~inherit_variants:true
          ?pos_fname ?pos_lnum
          file
    | None ->
        Atd.Util.read_channel
          ~expand:false ~inherit_fields:true ~inherit_variants:true
          ?pos_fname ?pos_lnum
          stdin
  in

  let tsort =
    if all_rec then
      function m -> [ (true, m) ]
    else
      Atd.Util.tsort
  in
  let m1 = tsort m0 in
  let defs1 = Oj_mapping.defs_of_atd_modules m1 ~target in
  let (m1', original_types) =
    Atd.Expand.expand_module_body ~keep_poly:true m0
  in
  let m2 = tsort m1' in
  (* m0 = original type definitions
     m1 = original type definitions after dependency analysis
     m2 = monomorphic type definitions after dependency analysis *)
  let ocaml_typedefs =
    Ocaml.ocaml_of_atd ~pp_convs ~target:Json ~type_aliases (head, m1) in
  let defs = Oj_mapping.defs_of_atd_modules m2 ~target in
  let header =
    let src =
      match atd_file with
        None -> "stdin"
      | Some path -> sprintf "%S" (Filename.basename path)
    in
    sprintf "\
(* Auto-generated from %s *)
[@@@ocaml.warning \"-27-32-35-39\"]" src
  in
  let mli =
    make_mli ~header ~opens ~with_typedefs ~with_create ~with_fundefs
      ocaml_typedefs (Mapping.make_deref defs1) defs1
  in
  let ml =
    make_ml ~header ~opens ~with_typedefs ~with_create ~with_fundefs
      ~std ~unknown_field_handler
      ~force_defaults ~preprocess_input ~original_types
      ~ocaml_version
      ocaml_typedefs (Mapping.make_deref defs) defs
  in
  Ox_emit.write_ocaml out mli ml
atd-2.1.0/atdgen/src/oj_emit.mli000066400000000000000000000007421357165332000164540ustar00rootroot00000000000000(** OCaml-Json code generator. *)

val make_ocaml_files
  :opens:string list
  -> with_typedefs:bool
  -> with_create:bool
  -> with_fundefs:bool
  -> all_rec:bool
  -> std:bool
  -> unknown_field_handler:string option
  -> pos_fname:string option
  -> pos_lnum:int option
  -> type_aliases:string option
  -> force_defaults:bool
  -> preprocess_input:string option
  -> ocaml_version:(int * int) option
  -> pp_convs:Ocaml.pp_convs
  -> string option
  -> Ox_emit.target
  -> unit
atd-2.1.0/atdgen/src/oj_mapping.ml000066400000000000000000000130221357165332000167730ustar00rootroot00000000000000open Atd.Import
open Atd.Ast
open Mapping

type t = (Ocaml.Repr.t, Json.json_repr) Mapping.mapping
type variant_mapping = (Ocaml.Repr.t, Json.json_repr) Mapping.variant_mapping

(*
  Translation of the types into the ocaml/json mapping.
*)

let check_json_sum loc json_sum_param variants =
  if json_sum_param.Json.json_open_enum then (
    let variants_with_arg =
      List.filter (function {var_arg = Some _; _} -> true | _ -> false) variants
    in
    match variants_with_arg with
    | [] ->
        Error.error loc
          "Missing catch-all case of the form `| Other of string`, \
           required by ."
    | [x] -> (
        match x.var_arg with
        | None -> assert false
        | Some (String _) -> ()
        | Some mapping ->
            let loc = Mapping.loc_of_mapping mapping in
            Error.error loc
              "The argument of this variant must be of type string \
               as imposed by ."
      )
    | _ ->
        Error.error loc
          "Multiple variants have arguments, which doesn't make sense \
           when combined with ."
  )

let rec mapping_of_expr (x : type_expr) =
  match x with
  | Sum (loc, l, an) ->
      let ocaml_t = Ocaml.Repr.Sum (Ocaml.get_ocaml_sum Json an) in
      let json_sum_param = Json.get_json_sum an in
      let json_t = Json.Sum (Json.get_json_sum an) in
      let variants = List.map mapping_of_variant l in
      check_json_sum loc json_sum_param variants;
      Sum (loc, Array.of_list variants,
           ocaml_t, json_t)

  | Record (loc, l, an) ->
      let ocaml_t = Ocaml.Repr.Record (Ocaml.get_ocaml_record Json an) in
      let ocaml_field_prefix = Ocaml.get_ocaml_field_prefix Json an in
      let json_t = Json.Record (Json.get_json_record an) in
      Record (loc,
              Array.of_list
                (List.map (mapping_of_field ocaml_field_prefix) l),
              ocaml_t, json_t)

  | Tuple (loc, l, _) ->
      let ocaml_t = Ocaml.Repr.Tuple in
      let json_t = Json.Tuple in
      Tuple (loc, Array.of_list (List.map mapping_of_cell l),
             ocaml_t, json_t)

  | List (loc, x, an) ->
      let ocaml_t = Ocaml.Repr.List (Ocaml.get_ocaml_list Json an) in
      let json_t = Json.List (Json.get_json_list an) in
      List (loc, mapping_of_expr x, ocaml_t, json_t)

  | Option (loc, x, _) ->
      let ocaml_t = Ocaml.Repr.Option in
      let json_t = Json.Option in
      Option (loc, mapping_of_expr x, ocaml_t, json_t)

  | Nullable (loc, x, _) ->
      let ocaml_t = Ocaml.Repr.Nullable in
      let json_t = Json.Nullable in
      Nullable (loc, mapping_of_expr x, ocaml_t, json_t)

  | Shared (loc, _, _) ->
      Error.error loc "Sharing is not supported by the JSON interface"

  | Wrap (loc, x, an) ->
      let ocaml_t =
        Ocaml.Repr.Wrap (Ocaml.get_ocaml_wrap ~type_param:[] Json loc an) in
      let json_t = Json.Wrap in
      Wrap (loc, mapping_of_expr x, ocaml_t, json_t)

  | Name (loc, (_, s, l), an) ->
      (match s with
         "unit" ->
           Unit (loc, Unit, Unit)
       | "bool" ->
           Bool (loc, Bool, Bool)
       | "int" ->
           let o = Ocaml.get_ocaml_int Json an in
           Int (loc, Int o, Int)
       | "float" ->
           let j = Json.get_json_float an in
           Float (loc, Float, Float j)
       | "string" ->
           String (loc, String, String)
       | s ->
           Name (loc, s, List.map mapping_of_expr l, None, None)
      )
  | Tvar (loc, s) ->
      Tvar (loc, s)

and mapping_of_cell (cel_loc, x, an) =
  { cel_loc
  ; cel_value = mapping_of_expr x
  ; cel_arepr =
      Ocaml.Repr.Cell
        { Ocaml.ocaml_default = Ocaml.get_ocaml_default Json an
        ; ocaml_fname = ""
        ; ocaml_mutable = false
        ; ocaml_fdoc = Atd.Doc.get_doc cel_loc an
        }
  ; cel_brepr = Json.Cell
  }

and mapping_of_variant = function
  | Inherit _ -> assert false
  | Variant (var_loc, (var_cons, an), o) ->
      { var_loc
      ; var_cons
      ; var_arg = Option.map mapping_of_expr o
      ; var_arepr = Ocaml.Repr.Variant
            { Ocaml.ocaml_cons = Ocaml.get_ocaml_cons Json var_cons an
            ; ocaml_vdoc = Atd.Doc.get_doc var_loc an
            }
      ; var_brepr =
          Json.Variant
            { Json.json_cons = Json.get_json_cons var_cons an
            }
      }

and mapping_of_field ocaml_field_prefix = function
  | `Inherit _ -> assert false
  | `Field (f_loc, (f_name, f_kind, an), x) ->
      let { Ox_mapping.ocaml_default; unwrapped } =
        Ox_mapping.analyze_field Json f_loc f_kind an in
      { f_loc
      ; f_name
      ; f_kind
      ; f_value = mapping_of_expr x
      ; f_arepr = Ocaml.Repr.Field
            { Ocaml.ocaml_default
            ; ocaml_fname =
                Ocaml.get_ocaml_fname Json (ocaml_field_prefix ^ f_name) an
            ; ocaml_mutable = Ocaml.get_ocaml_mutable Json an
            ; ocaml_fdoc = Atd.Doc.get_doc f_loc an
            }
      ; f_brepr = Json.Field
            { Json.json_fname = Json.get_json_fname f_name an
            ; json_unwrapped = unwrapped
            }
      }

let defs_of_atd_modules l ~(target : Ocaml.target)=
  (match target with
   | Json
   | Bucklescript -> ()
   | t -> invalid_arg "target must be json or bucklescript");
  List.map (fun (is_rec, l) ->
    ( is_rec
    , List.map (function Atd.Ast.Type atd ->
        Ox_emit.def_of_atd atd ~target ~external_:Json.External
          ~mapping_of_expr ~def:Json.Def
      ) l
    )
  ) l

let json_normalizer_of_adapter_path module_ =
  module_ ^ ".normalize"

let json_restorer_of_adapter_path module_ =
  module_ ^ ".restore"
atd-2.1.0/atdgen/src/oj_mapping.mli000066400000000000000000000007571357165332000171570ustar00rootroot00000000000000(** OCaml-Json decorated ATD AST. *)

type t = (Ocaml.Repr.t, Json.json_repr) Mapping.mapping
type variant_mapping = (Ocaml.Repr.t, Json.json_repr) Mapping.variant_mapping

val defs_of_atd_modules
  : ('a * Atd.Ast.module_body) list
  -> target:Ocaml.target
  -> ('a * (Ocaml.Repr.t, Json.json_repr) Mapping.def list) list

(** "A.B" -> "A.B.normalize" *)
val json_normalizer_of_adapter_path : string -> string

(** "A.B" -> "A.B.restore" *)
val json_restorer_of_adapter_path : string -> string
atd-2.1.0/atdgen/src/ov_emit.ml000066400000000000000000000301731357165332000163200ustar00rootroot00000000000000(*
  Validators of OCaml data whose types are defined using ATD.
*)

open Atd.Import
open Indent

open Atd.Ast
open Mapping
open Ov_mapping

let make_ocaml_validate_intf ~with_create buf deref defs =
  List.concat_map snd defs
  |> List.iter (fun x ->
    if with_create && Ox_emit.is_exportable x then (
      let create_record_intf, _ =
        Ox_emit.make_record_creator deref x
      in
      bprintf buf "%s" create_record_intf;
    );

    let full_name = Ox_emit.get_full_type_name x in
    let validator_params =
      String.concat "" (
        List.map
          (fun s ->
             sprintf "\n  (Atdgen_runtime.Util.Validation.path -> '%s -> \
                      Atdgen_runtime.Util.Validation.error option) ->" s)
          x.def_param
      )
    in
    let s = x.def_name in
    if Ox_emit.is_exportable x then (
      bprintf buf "\
val validate_%s :%s
  Atdgen_runtime.Util.Validation.path -> %s -> Atdgen_runtime.Util.Validation.error option
  (** Validate a value of type {!%s}. *)

"
        s validator_params
        full_name
        s
    )
  )

let get_fields a =
  let all =
    List.map (
      fun x ->
        match x.f_arepr with
          Ocaml.Repr.Field o -> (x, o.Ocaml.ocaml_fname)
        | _ -> assert false
    )
      (Array.to_list a)
  in
  List.filter (
    function
      { f_brepr = (None, shallow) ; _ }, _ -> not shallow
    | _ -> assert false
  ) all

let rec forall : Indent.t list -> Indent.t list = function
  | [] -> []
  | [x] -> [x]
  | x :: l ->
      [
        Line "match";
        Block [x];
        Line "with";
        Block [
          Line "| Some _ as err -> err";
          Line "| None ->";
          Block (forall l);
        ]
      ]

let return_true_paren = "(fun _ _ -> None)"

let opt_validator = function
    None -> [ Line "fun _ _ -> None" ]
  | Some s -> [ Line s ]

let opt_validator_s = function
    None -> "(fun _ _ -> None)"
  | Some s -> sprintf "( %s )" s


let prepend_validator opt l =
  match opt with
    None -> l
  | Some s ->
      [
        Line (sprintf "match ( %s ) path x with" s);
        Block [
          Line "| Some _ as err -> err";
          Line "| None ->";
          Block l;
        ]
      ]

let prepend_validator_s v s2 =
  match v with
    None -> s2
  | Some s1 ->
      sprintf "(fun path x -> \
               match ( %s ) path x with \
               | Some _ as err -> err \
               | None -> (%s) path x)" s1 s2

let prepend_validator_f v l =
  match v with
    None -> l
  | Some s ->
      [
        Line "(fun path x ->";
        Block [
          Line (sprintf "(match ( %s ) path x with" s);
          Block [
            Line "| Some _ as err -> err";
            Line "| None -> (";
            Block [
              Block l;
              Line ") path x";
            ]
          ];
          Line ")";
        ];
        Line ")";
      ]

(*
  ('a, 'b) t ->
    validate_t validate__a validate__b
  ('a, foo) t ->
    validate_t validate__a validate_foo
  ('a, (foo, 'b) bar) t ->
    validate_t validate__a (validate_bar validate_foo validate__b)
*)
let rec get_validator_name
    ?(paren = false)
    ?(name_f = fun s -> "validate_" ^ s)
    (x : ov_mapping) : string =

  match x with
    Unit (_, Unit, v)
  | Bool (_, Bool, v)
  | Int (_, Int _, v)
  | Float (_, Float, v)
  | String (_, String, v) ->
      (match v with
         (None, true) -> return_true_paren
       | (Some s, true) -> s
       | (_, false) -> assert false
      )
  | Tvar (_, s) -> "validate_" ^ (Ox_emit.name_of_var s)

  | Name (_, s, args, None, opt) ->
      let v1 =
        let l =
          List.map (get_validator_name ~paren:true) args in
        let s = String.concat " " (name_f s :: l) in
        if paren && l <> [] then "(" ^ s ^ ")"
        else s
      in
      (match opt with
         None -> v1
       | Some (o, false) -> prepend_validator_s o v1
       | Some (o, true) -> opt_validator_s o
      )

  | External (_, _, args,
              External (_, main_module, ext_name),
              v) ->
      (match v with
         (o, false) ->
           prepend_validator_s o (
             let f = main_module ^ "." ^ name_f ext_name in
             let l = List.map (get_validator_name ~paren:true) args in
             let s = String.concat " " (f :: l) in
             if paren && l <> [] then "(" ^ s ^ ")"
             else s
           )
       | (_, true) -> assert false
      )

  | _ -> assert false


let get_left_validator_name name param =
  let args = List.map (fun s -> Tvar (dummy_loc, s)) param in
  get_validator_name (Name (dummy_loc, name, args, None, None))

let rec make_validator (x : ov_mapping) : Indent.t list =
  match x with
    Unit _
  | Bool _
  | Int _
  | Float _
  | String _
  | Name _
  | External _
  | Tvar _ -> [ Line (get_validator_name x) ]

  | Sum (_, a, Sum x, (v, shallow)) ->
      if shallow then
        opt_validator v
      else
        let tick = Ocaml.tick x in
        let body : Indent.t list =
          [
            Line "match x with";
            Block (
              Array.to_list (
                Array.map
                  (fun x -> Inline (make_variant_validator tick x))
                  a
              )
            )
          ]
        in
        [
          Annot ("fun", Line "fun path x ->");
          Block (prepend_validator v body);
        ]

  | Record (_, a, Record o, (v, shallow)) ->
      if shallow then
        opt_validator v
      else
        [
          Annot ("fun", Line "fun path x ->");
          Block (prepend_validator v (make_record_validator a o));
        ]

  | Tuple (_, a, Tuple, (v, shallow)) ->
      if shallow then
        opt_validator v
      else
        let len = Array.length a in
        let l = Array.to_list (Array.mapi (fun i x -> (i, x)) a) in
        let l = List.filter (fun (_, x) -> not (snd x.cel_brepr)) l in
        let l =
          List.map (
            fun (i, x) ->
              Inline [
                Line (sprintf "(let %s = x in" (Ox_emit.nth "x" i len));
                Line "(";
                Block (make_validator x.cel_value);
                Line (sprintf ") (`Index %i :: path) x" i);
                Line ")"
              ]
          ) l
        in
        let l = forall l
        in
        [
          Annot ("fun", Line "fun path x ->");
          Block (prepend_validator v l);
        ]

  | List (_, x, List o, (v, shallow)) ->
      if shallow then
        opt_validator v
      else
        let validate =
          match o with
            List -> "Atdgen_runtime.Ov_run.validate_list ("
          | Array -> "Atdgen_runtime.Ov_run.validate_array ("
        in
        prepend_validator_f v [
          Line validate;
          Block (make_validator x);
          Line ")";
        ]

  | Option (_, x, Option, (v, shallow))
  | Nullable (_, x, Nullable, (v, shallow)) ->
      if shallow then
        opt_validator v
      else
        prepend_validator_f v [
          Line "Atdgen_runtime.Ov_run.validate_option (";
          Block (make_validator x);
          Line ")";
        ]

  | Wrap (_, x, Wrap _, (v, shallow)) ->
      if shallow then
        opt_validator v
      else
        prepend_validator_f v (make_validator x)

  | _ -> assert false



and make_variant_validator tick x :
  Indent.t list =
  let o =
    match x.var_arepr, x.var_brepr with
      Variant o, (None, _) -> o
    | _ -> assert false
  in
  let ocaml_cons = o.Ocaml.ocaml_cons in
  match x.var_arg with
    None ->
      [
        Line (sprintf "| %s%s -> None" tick ocaml_cons)
      ]
  | Some v ->
      [
        Line (sprintf "| %s%s x ->" tick ocaml_cons);
        Block [
          Line "(";
          Block (make_validator v);
          Line ") path x"
        ]
      ]

and make_record_validator a record_kind =
  let dot = Ocaml.dot record_kind in
  let fields = get_fields a in
  assert (fields <> []);
  let validate_fields : Indent.t list =
    List.map (
      fun (x, ocaml_fname) ->
        Inline [
          Line "(";
          Block (make_validator x.Mapping.f_value);
          Line (sprintf
                  ") (`Field %S :: path) x%s%s" ocaml_fname dot ocaml_fname);
        ]
    ) fields
  in
  forall validate_fields

let make_ocaml_validator ~original_types is_rec let1 def =
  let x = Option.value_exn def.def_value in
  let name = def.def_name in
  let type_constraint = Ox_emit.get_type_constraint ~original_types def in
  let param = def.def_param in
  let validate = get_left_validator_name name param in
  let validator_expr = make_validator x in
  let eta_expand = is_rec && not (Ox_emit.is_lambda validator_expr) in
  let needs_annot = Ox_emit.needs_type_annot x in
  let extra_param, extra_args, type_annot =
    match eta_expand, needs_annot with
    | true, false -> " path x", " path x", None
    | true, true -> sprintf " path (x : %s)" type_constraint, " path x", None
    | false, false -> "", "", None
    | false, true -> "", "", Some (sprintf "_ -> %s -> _" type_constraint)
  in
  [
    Line (sprintf "%s %s = ("
            let1
            (Ox_emit.opt_annot_def type_annot (validate ^ extra_param)));
    Block (List.map Indent.strip validator_expr);
    Line (sprintf ")%s" extra_args);
  ]


let make_ocaml_validate_impl ~with_create ~original_types buf deref defs =
  defs
  |> List.concat_map (fun (is_rec, l) ->
    let l = List.filter (fun x -> x.def_value <> None) l in
    let validators =
      List.map_first (fun ~is_first def ->
        let let1, _ = Ox_emit.get_let ~is_rec ~is_first in
        make_ocaml_validator ~original_types is_rec let1 def
      ) l
    in
    List.flatten validators)
  |> Indent.to_buffer buf;
  Ox_emit.maybe_write_creator_impl ~with_create deref buf defs


(*
  Glue
*)

let make_mli
    ~header ~opens ~with_typedefs ~with_create ~with_fundefs
    ocaml_typedefs deref defs =
  let buf = Buffer.create 1000 in
  bprintf buf "%s\n" header;
  Ox_emit.write_opens buf opens;
  if with_typedefs then
    bprintf buf "%s\n" ocaml_typedefs;
  if with_typedefs && with_fundefs then
    bprintf buf "\n";
  if with_fundefs then
    make_ocaml_validate_intf ~with_create buf deref defs;
  Buffer.contents buf

let make_ml
    ~header ~opens ~with_typedefs ~with_create ~with_fundefs
    ~original_types ocaml_typedefs deref defs =
  let buf = Buffer.create 1000 in
  bprintf buf "%s\n" header;
  Ox_emit.write_opens buf opens;
  if with_typedefs then
    bprintf buf "%s\n" ocaml_typedefs;
  if with_typedefs && with_fundefs then
    bprintf buf "\n";
  if with_fundefs then
    make_ocaml_validate_impl ~with_create ~original_types buf deref defs;
  Buffer.contents buf

let make_ocaml_files
    ~opens
    ~with_typedefs
    ~with_create
    ~with_fundefs
    ~all_rec
    ~pos_fname
    ~pos_lnum
    ~type_aliases
    ~force_defaults:_
    ~ocaml_version:_
    ~pp_convs
    atd_file out =
  let ((head, m0), _) =
    match atd_file with
      Some file ->
        Atd.Util.load_file
          ~expand:false ~inherit_fields:true ~inherit_variants:true
          ?pos_fname ?pos_lnum
          file
    | None ->
        Atd.Util.read_channel
          ~expand:false ~inherit_fields:true ~inherit_variants:true
          ?pos_fname ?pos_lnum
          stdin
  in
  let tsort =
    if all_rec then
      function m -> [ (true, m) ]
    else
      Atd.Util.tsort
  in
  let m1 = tsort m0
  in
  let defs1 = Ov_mapping.defs_of_atd_modules m1 in
  let (m1', original_types) =
    Atd.Expand.expand_module_body ~keep_poly:true m0
  in
  let m2 = tsort m1' in
  (* m0 = original type definitions
     m1 = original type definitions after dependency analysis
     m2 = monomorphic type definitions after dependency analysis *)
  let ocaml_typedefs =
    Ocaml.ocaml_of_atd ~pp_convs ~target:Validate ~type_aliases (head, m1) in
  let defs = Ov_mapping.defs_of_atd_modules m2 in
  let header =
    let src =
      match atd_file with
        None -> "stdin"
      | Some path -> sprintf "%S" (Filename.basename path)
    in
    sprintf {|(* Auto-generated from %s *)
              [@@@ocaml.warning "-27-32-35-39"]|} src
  in
  let mli =
    make_mli ~header ~opens ~with_typedefs ~with_create ~with_fundefs
      ocaml_typedefs (Mapping.make_deref defs1) defs1
  in
  let ml =
    make_ml ~header ~opens ~with_typedefs ~with_create ~with_fundefs
      ~original_types ocaml_typedefs (Mapping.make_deref defs) defs
  in
  Ox_emit.write_ocaml out mli ml
atd-2.1.0/atdgen/src/ov_emit.mli000066400000000000000000000006361357165332000164720ustar00rootroot00000000000000(** Code generator for OCaml validators. *)

val make_ocaml_files
  : opens:string list
  -> with_typedefs:bool
  -> with_create:bool
  -> with_fundefs:bool
  -> all_rec:bool
  -> pos_fname:string option
  -> pos_lnum:int option
  -> type_aliases:string option
  -> force_defaults:_ (* TODO unused *)
  -> ocaml_version:_ (* TODO unused *)
  -> pp_convs:Ocaml.pp_convs
  -> string option -> Ox_emit.target -> unit
atd-2.1.0/atdgen/src/ov_mapping.ml000066400000000000000000000226311357165332000170150ustar00rootroot00000000000000open Atd.Import
open Atd.Ast
open Mapping

type ov_mapping =
    (Ocaml.Repr.t, Validate.validate_repr) Mapping.mapping

(*
  Determine whether a type expression does not need validation.

  1. Flatten.
     For each type expression of interest, produce the list
     of all type expressions on which it depends.

  2. Read annotations.
     If any of the type expressions has a validator annotation or if
     on the type expressions is abstract, then the result is false.
*)

let get_def defs name : type_expr option =
  try Some (Hashtbl.find defs name)
  with Not_found -> None

let noval x =
  let an = Atd.Ast.annot_of_type_expr x in
  Validate.get_validator an = None

module H = Hashtbl.Make (
  struct
    type t = type_expr
    let equal = ( == )
    let hash = Hashtbl.hash
  end
)

let for_all_children f x0 =
  let is_root = ref true in
  try
    Atd.Ast.fold (
      fun x () ->
        if !is_root then (
          is_root := false;
          assert (x == x0);
        )
        else
          if not (f x) then
            raise Exit
    ) x0 ();
    true
  with Exit ->
    false

(*
  Return if an expression is shallow, i.e. it does not require to call
  a validation function other than the one possibly given
  by an annotation  on this node.

  Shallow:
    int
    int 
    { x : int } 
    t   (* where t is defined as: type t = int *)

  Not shallow:
    t   (* where t is defined as: type t = int  *)
    { x : int  }
    'a t
    t   (* where t is defined as: type t = abstract *)
*)
let rec scan_expr
    (defs : (string, type_expr) Hashtbl.t)
    (visited : unit H.t)
    (results : bool H.t)
    (x : type_expr) : bool =

  if not (H.mem visited x) then (
    H.add visited x ();
    try H.find results x
    with Not_found ->
      name_is_shallow defs visited results x
      && for_all_children (
        fun x ->
          noval x
          && scan_expr defs visited results x
      ) x
  )
  else
    (* neutral for the && operator *)
    true

and name_is_shallow defs visited results x =
  match x with
    Name (_, (_, name, _), _) ->
      (match get_def defs name with
         None ->
           (match name with
              "unit"
            | "bool"
            | "int"
            | "float"
            | "string" -> true
            | _ -> false
           )
       | Some x -> noval x && scan_expr defs visited results x
      )

  | Tvar (_, _) -> false
  | _ -> (* already verified in the call to scan_expr above *) true


let iter f x =
  Atd.Ast.fold (fun x () -> f x) x ()

let scan_top_expr
    (defs : (string, type_expr) Hashtbl.t)
    (results : bool H.t)
    (x : type_expr) : unit =

  (* Force-scan all sub-expressions *)
  iter (
    fun x ->
      if not (H.mem results x) then (
        let b = scan_expr defs (H.create 10) results x in
        (try
           let b0 = H.find results x in
           assert (b0 = b);
         with Not_found -> ());
        H.replace results x b
      )
  ) x

let make_is_shallow defs =
  let results = H.create 100 in
  Hashtbl.iter (
    fun _ x -> scan_top_expr defs results x
  ) defs;
  fun x ->
    try
      H.find results x
    with Not_found -> assert false

(*
  Translation of the types into the ocaml/validate mapping.
*)

let rec mapping_of_expr
    (is_shallow : type_expr -> bool)
    (x0 : type_expr) : ov_mapping =

  let v an = Validate.get_validator an in
  let v2 an x = (Validate.get_validator an, is_shallow x) in
  match x0 with
    Sum (loc, l, an) ->
      let ocaml_t = Ocaml.Repr.Sum (Ocaml.get_ocaml_sum Validate an) in
      Sum (loc, Array.of_list (List.map (mapping_of_variant is_shallow) l),
           ocaml_t, v2 an x0)

  | Record (loc, l, an) ->
      let ocaml_t = Ocaml.Repr.Record (Ocaml.get_ocaml_record Validate an) in
      let ocaml_field_prefix = Ocaml.get_ocaml_field_prefix Validate an in
      Record (loc,
              Array.of_list
                (List.map
                   (mapping_of_field is_shallow ocaml_field_prefix) l),
              ocaml_t, v2 an x0)

  | Tuple (loc, l, an) ->
      let ocaml_t = Ocaml.Repr.Tuple in
      Tuple (loc, Array.of_list (List.map (mapping_of_cell is_shallow) l),
             ocaml_t, v2 an x0)

  | List (loc, x, an) ->
      let ocaml_t = Ocaml.Repr.List (Ocaml.get_ocaml_list Validate an) in
      List (loc, mapping_of_expr is_shallow x, ocaml_t, v2 an x0)

  | Option (loc, x, an) ->
      let ocaml_t = Ocaml.Repr.Option in
      Option (loc, mapping_of_expr is_shallow x, ocaml_t, v2 an x0)

  | Nullable (loc, x, an) ->
      let ocaml_t = Ocaml.Repr.Nullable in
      Nullable (loc, mapping_of_expr is_shallow x, ocaml_t, v2 an x0)

  | Shared (_, _, _) ->
      failwith "Sharing is not supported"

  | Wrap (loc, x, an) ->
      let w = Ocaml.get_ocaml_wrap ~type_param:[] Validate loc an in
      let ocaml_t = Ocaml.Repr.Wrap w in
      let validator =
        match w with
          None -> v2 an x0
        | Some _ -> v an, true
      in
      Wrap (loc, mapping_of_expr is_shallow x, ocaml_t, validator)

  | Name (loc, (_, s, l), an) ->
      (match s with
         "unit" ->
           Unit (loc, Unit, (v an, true))
       | "bool" ->
           Bool (loc, Bool, (v an, true))
       | "int" ->
           let o = Ocaml.get_ocaml_int Validate an in
           Int (loc, Int o, (v an, true))
       | "float" ->
           Float (loc, Float, (v an, true))
       | "string" ->
           String (loc, String, (v an, true))
       | s ->
           let validator =
             match v2 an x0 with
               None, true -> None
             | x -> Some x
           in
           Name (loc, s, List.map (mapping_of_expr is_shallow) l,
                 None, validator)
      )
  | Tvar (loc, s) ->
      Tvar (loc, s)

and mapping_of_cell is_shallow (loc, x, an) =
  let default = Ocaml.get_ocaml_default Validate an in
  let doc = Atd.Doc.get_doc loc an in
  let ocaml_t =
    Ocaml.Repr.Cell {
      Ocaml.ocaml_default = default;
      ocaml_fname = "";
      ocaml_mutable = false;
      ocaml_fdoc = doc;
    }
  in
  {
    cel_loc = loc;
    cel_value = mapping_of_expr is_shallow x;
    cel_arepr = ocaml_t;
    cel_brepr = (None, noval x && is_shallow x)
  }


and mapping_of_variant is_shallow = function
    Variant (loc, (s, an), o) ->
      let ocaml_cons = Ocaml.get_ocaml_cons Validate s an in
      let doc = Atd.Doc.get_doc loc an in
      let ocaml_t =
        Ocaml.Repr.Variant {
          Ocaml.ocaml_cons = ocaml_cons;
          ocaml_vdoc = doc;
        }
      in
      let arg, validate_t =
        match o with
          None ->
            None, (None, true)
        | Some x ->
            (Some (mapping_of_expr is_shallow x),
             (None, noval x && is_shallow x))
      in
      {
        var_loc = loc;
        var_cons = s;
        var_arg = arg;
        var_arepr = ocaml_t;
        var_brepr = validate_t;
      }

  | Inherit _ -> assert false

and mapping_of_field is_shallow ocaml_field_prefix = function
    `Field (loc, (s, fk, an), x) ->
      let fvalue = mapping_of_expr is_shallow x in
      let ocaml_default =
        match fk, Ocaml.get_ocaml_default Validate an with
          Required, None -> None
        | Optional, None -> Some "None"
        | (Required | Optional), Some _ ->
            Error.error loc "Superfluous default OCaml value"
        | With_default, Some s -> Some s
        | With_default, None ->
            (* will try to determine implicit default value later *)
            None
      in
      let ocaml_fname = Ocaml.get_ocaml_fname Validate (ocaml_field_prefix ^ s) an in
      let ocaml_mutable = Ocaml.get_ocaml_mutable Validate an in
      let doc = Atd.Doc.get_doc loc an in
      { f_loc = loc;
        f_name = s;
        f_kind = fk;
        f_value = fvalue;

        f_arepr = Ocaml.Repr.Field {
          Ocaml.ocaml_default = ocaml_default;
          ocaml_fname = ocaml_fname;
          ocaml_mutable = ocaml_mutable;
          ocaml_fdoc = doc;
        };

        f_brepr = (None, noval x && is_shallow x);
      }

  | `Inherit _ -> assert false


let def_of_atd is_shallow (loc, (name, param, an), x) =
  let ocaml_predef = Ocaml.get_ocaml_predef Validate an in
  let doc = Atd.Doc.get_doc loc an in
  let o =
    match as_abstract x with
    | Some (_, an2) ->
        Ocaml.get_ocaml_module_and_t Validate name an
        |> Option.map (fun (types_module, main_module, ext_name) ->
          let args = List.map (fun s -> Tvar (loc, s)) param in
          External (loc, name, args,
                    Ocaml.Repr.External (types_module, main_module, ext_name),
                    (Validate.get_validator an2, false))
        )
    | None -> Some (mapping_of_expr is_shallow x)
  in
  {
    def_loc = loc;
    def_name = name;
    def_param = param;
    def_value = o;
    def_arepr =
      Ocaml.Repr.Def { Ocaml.ocaml_predef = ocaml_predef;
                       ocaml_ddoc = doc; };
    def_brepr = (None, false);
  }

let fill_def_tbl defs l =
  List.iter (
    function Atd.Ast.Type (_, (name, _, _), x) -> Hashtbl.add defs name x
  ) l

let init_def_tbl () =
  Hashtbl.create 100

let make_def_tbl2 l =
  let defs = init_def_tbl () in
  List.iter (fun (_, l) -> fill_def_tbl defs l) l;
  defs

let defs_of_atd_module_gen is_shallow l =
  List.map (function Atd.Ast.Type def -> def_of_atd is_shallow def) l

let defs_of_atd_modules l =
  let defs = make_def_tbl2 l in
  let is_shallow = make_is_shallow defs in
  List.map (fun (is_rec, l) -> (is_rec, defs_of_atd_module_gen is_shallow l)) l
atd-2.1.0/atdgen/src/ov_mapping.mli000066400000000000000000000004031357165332000171570ustar00rootroot00000000000000(** Decorated ATD AST for OCaml validators. *)

type ov_mapping =
    (Ocaml.Repr.t, Validate.validate_repr) Mapping.mapping

val defs_of_atd_modules
  : ('a * Atd.Ast.module_body) list
  -> ('a * (Ocaml.Repr.t, Validate.validate_repr) Mapping.def list) list
atd-2.1.0/atdgen/src/ox_emit.ml000066400000000000000000000271341357165332000163250ustar00rootroot00000000000000(*
  Tools shared between OCaml code generators.
  (ox means OCaml-X)
*)

open Atd.Import
open Mapping

type 'a expr = (Ocaml.Repr.t, 'a) Mapping.mapping
type 'a def = (Ocaml.Repr.t, 'a) Mapping.def
type 'a grouped_defs = (bool * 'a def list) list

type name = (loc * loc * string)
(* location of the containing record or variant,
   location of the field definition,
   field/constructor name *)

type names = {
  field_names : name list list;
  poly_variant_names : name list list;
  classic_variant_names : name list list;
}

type target =
  | Files of string
  | Stdout

let rec extract_names_from_expr ?(is_root = false) root_loc acc (x : 'a expr) =
  match x with
    Unit _
  | Bool _
  | Int _
  | Float  _
  | String _ -> acc
  | Sum (loc, va, o, _) ->
      let l, (fn, pvn, cvn) =
        Array.fold_left (extract_names_from_variant root_loc) ([], acc) va
      in
      (match o with
         Sum x ->
           (match x with
              Poly -> (fn, l :: pvn, cvn)
            | Classic ->
                if is_root then (fn, pvn, l :: cvn)
                else
                  Error.error loc
                    "Anonymous classic variant types are not allowed \
                     by OCaml."
           )
       | _ -> assert false
      )

  | Record (loc, fa, _, _) ->
      if is_root then
        let l, (fn, pvn, cvn) =
          Array.fold_left (extract_names_from_field root_loc) ([], acc) fa
        in
        (l :: fn, pvn, cvn)
      else
        Error.error loc "Anonymous record types are not allowed by OCaml."

  | Tuple (_, ca, _, _) ->
      Array.fold_left (extract_names_from_cell root_loc) acc ca

  | List (_, x, _, _)
  | Option (_, x, _, _)
  | Nullable (_, x, _, _)
  | Wrap (_, x, _, _) ->
      extract_names_from_expr root_loc acc x

  | Name (_, _, l, _, _) ->
      List.fold_left (extract_names_from_expr root_loc) acc l

  | External (_, _, l, _, _) ->
      List.fold_left (extract_names_from_expr root_loc) acc l

  | Tvar _ -> acc

and extract_names_from_variant root_loc (l, acc) x =
  let l =
    match x.var_arepr with
      Variant v -> (root_loc, x.var_loc, v.Ocaml.ocaml_cons) :: l
    | _ -> assert false
  in
  match x.var_arg with
    None -> (l, acc)
  | Some x ->
      (l, extract_names_from_expr root_loc acc x)

and extract_names_from_field root_loc (l, acc) x =
  let l =
    match x.f_arepr with
      Field f -> (root_loc, x.f_loc, f.Ocaml.ocaml_fname) :: l
    | _ -> assert false
  in
  (l, extract_names_from_expr root_loc acc x.f_value)

and extract_names_from_cell root_loc acc x =
  extract_names_from_expr root_loc acc x.cel_value


let extract_ocaml_names_from_defs l =
  let fn, pvn, cvn =
    List.fold_left (
      fun acc def ->
        match def.def_value with
          None -> acc
        | Some x ->
            let root_loc = loc_of_mapping x in
            extract_names_from_expr ~is_root:true root_loc acc x
    ) ([], [], []) l
  in
  {
    field_names = List.rev fn;
    poly_variant_names = List.rev pvn;
    classic_variant_names = List.rev cvn;
  }

let check_duplicate_names container_kind field_kind l =
  let tbl = Hashtbl.create 200 in
  List.iter (
    fun (root_loc, loc, s) ->
      try
        let orig_loc = Hashtbl.find tbl s in
        let msg1 =
          sprintf "\
%s contains a %s that is already defined elsewhere
and cannot be reused."
            (String.capitalize_ascii container_kind) field_kind
        in
        let msg2 = sprintf "First definition of %s %s." field_kind s in
        let msg3 = sprintf "\
Impossible second definition of %s %s.

Use a different name, possibly by placing 
after the field name or variant name in the ATD type definition.
 can also be used after a whole record."
            field_kind s
        in
        if loc <> orig_loc then
          Error.error3
            root_loc msg1
            orig_loc msg2
            loc msg3
        else
          Error.error2
            root_loc msg1
            orig_loc msg2

      with Not_found ->
        Hashtbl.add tbl s loc
  ) l

let check_names x =
  check_duplicate_names "record type" "field name"
    (List.flatten x.field_names);
  check_duplicate_names "variant type" "constructor name"
    (List.flatten x.classic_variant_names)


let check grouped_defs =
  let x = extract_ocaml_names_from_defs (List.concat_map snd grouped_defs) in
  check_names x


let get_full_type_name x =
  let s = x.def_name in
  match x.def_param with
    [] -> s
  | [x] -> sprintf "'%s %s" x s
  | l ->
      let l = List.map (fun s -> "'" ^ s) l in
      sprintf "(%s) %s" (String.concat ", " l) s

let anon_param_type_name s n_param =
  match n_param with
  | 0 -> s
  | 1 -> "_ " ^ s
  | n ->
      let underscores = Array.make n "_" in
      let params = String.concat ", " (Array.to_list underscores) in
      "(" ^ params ^ ") " ^ s

(* Get a type expression that uses the original user-given name (e.g. not _1) *)
let get_type_constraint ~original_types def =
  try
    let (poly_name, n_params) = Hashtbl.find original_types def.def_name in
    anon_param_type_name poly_name n_params
  with Not_found ->
    get_full_type_name def


(* Classic variants and records need type annotations in order to allow
   constructor/field name disambiguation *)
let needs_type_annot (x : _ expr) =
  match x with
  | Record (_, _, Record Record, _)
  | Sum (_, _, Sum Classic, _) -> true
  | _ -> false

let insert_annot type_annot =
  match type_annot with
  | None -> ""
  | Some t -> sprintf " : %s" t

(* Add an optional type annotation on an OCaml expression or pattern *)
let opt_annot type_annot expr =
  match type_annot with
  | None -> expr
  | Some t -> sprintf "(%s : %s)" expr t

(* Add an optional type annotation after all function parameters
   in a let binding (last thing before the equal sign) *)
let opt_annot_def type_annot fun_param =
  match type_annot with
  | None -> fun_param
  | Some t -> sprintf "%s : %s" fun_param t


let write_file file s =
  let oc = open_out_bin file in
  output_string oc s;
  close_out oc

let write_ocaml out mli ml =
  match out with
    Stdout ->
      printf "\
struct
%s
end :
sig
%s
end
"
        ml mli;
      flush stdout

  | Files prefix ->
      write_file (prefix ^ ".mli") mli;
      write_file (prefix ^ ".ml") ml

let is_exportable def =
  let s = def.def_name in
  s <> "" && s.[0] <> '_'
  && def.def_value <> None

let make_record_creator deref x =
  match x.def_value with
    Some (Record (_, a, Ocaml.Repr.Record Ocaml.Record, _)) ->
      let s = x.def_name in
      let full_name = get_full_type_name x in
      let (intf_params, impl_params, impl_fields) =
        Array.map (Ocaml.map_record_creator_field deref) a
        |> Array.to_list
        |> List.map (fun { Ocaml. intf_params; impl_params; impl_fields } ->
          (intf_params, impl_params, impl_fields))
        |> List.split3
      in
      let intf =
        sprintf "\
val create_%s :%s
  unit -> %s
  (** Create a record of type {!%s}. *)

"
          s (String.concat "" intf_params)
          full_name
          s
      in
      let impl =
        sprintf "\
let create_%s %s
  () : %s =
  {%s
  }
"
          s (String.concat "" impl_params) full_name
          (String.concat "" impl_fields)
      in
      intf, impl

  | _ -> "", ""

let rec is_lambda (l : Indent.t list) =
  match l with
    [] -> false
  | x :: _ ->
      match x with
        Line _ -> false
      | Block l -> is_lambda l
      | Inline l -> is_lambda l
      | Annot ("fun", _) -> true
      | Annot (_, x) -> is_lambda [x]

let is_function = is_lambda

let name_of_var s = "_" ^ s

let nth name i len =
  Array.init len (fun j -> if i = j then name else "_")
  |> Array.to_list
  |> String.concat ", "

let get_let ~is_rec ~is_first =
  if is_first then
    if is_rec then "let rec", "and"
    else "let", "let"
  else "and", "and"

let write_opens buf l =
  List.iter (fun s -> bprintf buf "open %s\n" s) l;
  bprintf buf "\n"

let def_of_atd (loc, (name, param, an), x) ~target ~def ~external_
    ~mapping_of_expr =
  let ocaml_predef = Ocaml.get_ocaml_predef target an in
  let doc = Atd.Doc.get_doc loc an in
  let o =
    match as_abstract x with
      Some (_, _) ->
        Ocaml.get_ocaml_module_and_t target name an
        |> Option.map (fun (types_module, main_module, ext_name) ->
          let args = List.map (fun s -> Tvar (loc, s)) param in
          External
            (loc, name, args,
             Ocaml.Repr.External (types_module, main_module, ext_name),
             external_))
    | None -> Some (mapping_of_expr x)
  in
  {
    def_loc = loc;
    def_name = name;
    def_param = param;
    def_value = o;
    def_arepr =
      Ocaml.Repr.Def { Ocaml.ocaml_predef = ocaml_predef;
                       ocaml_ddoc = doc };
    def_brepr = def;
  }

let maybe_write_creator_impl ~with_create deref buf defs =
  if with_create then
    List.iter (
      fun (_, l) ->
        let l = List.filter is_exportable l in
        List.iter (
          fun x ->
            let _, impl = make_record_creator deref x in
            Buffer.add_string buf impl
        ) l
    ) defs

let maybe_write_creator_intf ~with_create deref buf x =
  if with_create && is_exportable x then (
    let create_record_intf, _ = make_record_creator deref x in
    bprintf buf "%s" create_record_intf;
    bprintf buf "\n"
  )

let default_value x deref =
  let ocamlf =
    match x.f_arepr with
    | Ocaml.Repr.Field o -> o
    | _ -> failwith "Ox_emit.default_value" in
  match x.f_kind, ocamlf.Ocaml.ocaml_default with
  | With_default, None ->
      begin match Ocaml.get_implicit_ocaml_default (deref x.f_value) with
        | None -> Error.error x.f_loc "Missing default field value"
        | Some d -> Some d
      end
  | With_default, Some d -> Some d
  | Optional, _ -> Some "None"
  | Required, _ -> None

let include_intf (x : (Ocaml.Repr.t, _) Mapping.def) =
  x.def_name <> "" && x.def_name.[0] <> '_' && x.def_value <> None

type field =
  { mapping : (Ocaml.Repr.t, Json.json_repr) Mapping.field_mapping
  ; ocaml_fname : string
  ; json_fname : string
  ; ocaml_default : string option
  ; optional : bool
  ; unwrapped : bool
  }

let get_fields deref a =
  List.map (fun x ->
    let ocamlf, jsonf =
      match x.f_arepr, x.f_brepr with
      | Ocaml.Repr.Field o, Json.Field j -> o, j
      | _ -> assert false
    in
    let ocaml_fname = ocamlf.Ocaml.ocaml_fname in
    let ocaml_default =
      match x.f_kind, ocamlf.Ocaml.ocaml_default with
      | With_default, None ->
          (match Ocaml.get_implicit_ocaml_default (deref x.f_value) with
           | None -> Error.error x.f_loc "Missing default field value"
           | Some d -> Some d
          )
      | With_default, Some d -> Some d
      | Optional, _ -> Some "None"
      | Required, _ -> None
    in
    let json_fname = jsonf.Json.json_fname in
    let optional = not (Atd.Ast.is_required x.f_kind) in
    let unwrapped = jsonf.Json.json_unwrapped in
    { mapping = x
    ; ocaml_fname
    ; ocaml_default
    ; json_fname
    ; optional
    ; unwrapped
    }
  ) (Array.to_list a)

let is_string deref x =
  (*
    Calling 'unwrap' allows us to ignore 'wrap' constructors
    and determine that the JSON representation is a string.
    This assumes that no '' annotation imposes
    another representation for the JSON string.
  *)
  match Mapping.unwrap deref x with
  | String _ -> true
  | _ -> false (* or maybe we just don't know *)

let get_assoc_type deref loc x =
  match deref x with
  | Tuple (_, [| k; v |], Ocaml.Repr.Tuple, Json.Tuple) ->
      if not (is_string deref k.cel_value) then
        Error.error loc "Due to  keys must be strings";
      (k.cel_value, v.cel_value)
  | _ ->
      Error.error loc "Expected due to : (string * _) list"
atd-2.1.0/atdgen/src/ox_emit.mli000066400000000000000000000061301357165332000164670ustar00rootroot00000000000000(** Utilities for writing OCaml code generators from a decorated ATD AST. *)

type 'a expr = (Ocaml.Repr.t, 'a) Mapping.mapping
type 'a def = (Ocaml.Repr.t, 'a) Mapping.def
type 'a grouped_defs = (bool * 'a def list) list

type target =
  | Files of string
  | Stdout

val get_full_type_name : (_, _) Mapping.def -> string

val is_exportable : (_, _) Mapping.def -> bool

val make_record_creator
  : ((Ocaml.Repr.t, 'a) Mapping.mapping
     -> (Ocaml.Repr.t, 'b) Mapping.mapping)
  -> (Ocaml.Repr.t, 'a) Mapping.def
  -> string * string

val opt_annot : string option -> string -> string

val opt_annot_def : string option -> string -> string

val insert_annot : string option -> string

val get_type_constraint
  : original_types:(string, string * int) Hashtbl.t
  -> ('a, 'b) Mapping.def
  -> string

(** Determine whether the start of the given block of code was annotated
    with the "fun" tag, indicating that it represents a lambda (anonymous
    function). *)
val is_lambda : Indent.t list -> bool

val is_function : Indent.t list -> bool
[@@deprecated "Please use 'is_lambda' instead of 'is_function'."]

val needs_type_annot : _ expr -> bool

val check : _ grouped_defs -> unit

val write_ocaml : target -> string -> string -> unit

val name_of_var : string -> string

val nth : string -> int -> int -> string

val get_let : is_rec:bool -> is_first:bool -> string * string

val write_opens : Buffer.t -> string list -> unit

val def_of_atd
  : Atd.Ast.loc
    * (string * string list * Atd.Annot.t)
    * Atd.Ast.type_expr
  -> target:Ocaml.target
  -> def:'a
  -> external_:'a
  -> mapping_of_expr:(Atd.Ast.type_expr -> (Ocaml.Repr.t, 'a) Mapping.mapping)
  -> (Ocaml.Repr.t, 'a) Mapping.def

val maybe_write_creator_impl
  : with_create:bool
  -> ((Ocaml.Repr.t, 'a) Mapping.mapping ->
      (Ocaml.Repr.t, 'b) Mapping.mapping)
  -> Buffer.t
  -> ('c * (Ocaml.Repr.t, 'a) Mapping.def list) list
  -> unit

val maybe_write_creator_intf
  : with_create:bool
  -> ((Ocaml.Repr.t, 'a) Mapping.mapping ->
      (Ocaml.Repr.t, 'b) Mapping.mapping)
  -> Buffer.t
  -> (Ocaml.Repr.t, 'a) Mapping.def
  -> unit

val default_value
  : (Ocaml.Repr.t, 'a) Mapping.field_mapping
  -> ((Ocaml.Repr.t, 'a) Mapping.mapping -> (Ocaml.Repr.t, 'b) Mapping.mapping)
  -> string option

val include_intf : (Ocaml.Repr.t, 'a) Mapping.def -> bool

type field =
  { mapping : (Ocaml.Repr.t, Json.json_repr) Mapping.field_mapping
  ; ocaml_fname : string
  ; json_fname : string
  ; ocaml_default : string option
  ; optional : bool
  ; unwrapped : bool
  }

val get_fields
  : ((Ocaml.Repr.t, Json.json_repr) Mapping.mapping
     -> (Ocaml.Repr.t, 'a) Mapping.mapping)
  -> (Ocaml.Repr.t, Json.json_repr) Mapping.field_mapping array
  -> field list

val is_string : (('a, 'b) Mapping.mapping -> ('a, 'b) Mapping.mapping) -> ('a, 'b) Mapping.mapping -> bool

val get_assoc_type : ((Ocaml.Repr.t, Json.json_repr) Mapping.mapping ->
  (Ocaml.Repr.t, Json.json_repr) Mapping.mapping) ->
    Mapping.loc ->
      (Ocaml.Repr.t, Json.json_repr) Mapping.mapping ->
        (Ocaml.Repr.t, Json.json_repr) Mapping.mapping *
          (Ocaml.Repr.t, Json.json_repr) Mapping.mapping
atd-2.1.0/atdgen/src/ox_mapping.ml000066400000000000000000000011751357165332000170170ustar00rootroot00000000000000open! Atd.Import
open Atd.Ast

type analyze_field =
  { ocaml_default : string option
  ; unwrapped : bool
  }

let analyze_field target loc (f_kind : field_kind) annot =
  let ocaml_default, unwrapped =
    match f_kind, Ocaml.get_ocaml_default target annot with
      Required, None -> None, false
    | Optional, None -> Some "None", true
    | (Required | Optional), Some _ ->
        Error.error loc "Superfluous default OCaml value"
    | With_default, Some s -> Some s, false
    | With_default, None ->
        (* will try to determine implicit default value later *)
        None, false
  in
  { ocaml_default
  ; unwrapped
  }
atd-2.1.0/atdgen/src/ox_mapping.mli000066400000000000000000000002571357165332000171700ustar00rootroot00000000000000open Atd.Ast

type analyze_field =
  { ocaml_default : string option
  ; unwrapped : bool
  }

val analyze_field : Ocaml.target -> loc -> field_kind -> annot -> analyze_field
atd-2.1.0/atdgen/src/string_match.ml000066400000000000000000000165741357165332000173510ustar00rootroot00000000000000open Printf
open Indent

type position = [ `Length | `Position of int | `End ]
type value = [ `Int of int | `Char of char ]

type 'a tree =
  [ `Node of (position * (value * 'a tree) list)
  | `Branch of ((position * value) list * 'a tree)
  | `Leaf of 'a ]

let group_by f l =
  let tbl = Hashtbl.create 20 in
  List.iter (
    fun x ->
      let k = f x in
      let r =
        try Hashtbl.find tbl k
        with Not_found ->
          let r = ref [] in
          Hashtbl.add tbl k r;
          r
      in
      r := x :: !r
  ) l;
  let l = Hashtbl.fold (fun k r l -> (k, List.rev !r) :: l) tbl [] in
  List.sort (fun (k1, _) (k2, _) -> compare k1 k2) l


let rec finish s pos =
  match pos with
    `End -> []
  | `Length ->
      (`Length, `Int (String.length s)) :: finish s (`Position 0)
  | `Position i ->
      if i < String.length s then
        (pos, `Char s.[i]) :: finish s (`Position (i+1))
      else
        finish s `End

let make_end_branch s pos x =
  match finish s pos with
    [] -> `Leaf x
  | l -> `Branch (l, `Leaf x)


(*
  Create branches where possible.
  As a result, all the nodes become part of a branch.
*)
let rec make_branches (x : 'a tree) : 'a tree =
  match x with
    `Leaf _ -> x
  | `Branch (l, x) ->
      (match make_branches x with
         `Branch (l2, x2) -> `Branch ((l @ l2), x2)
       | x -> `Branch (l, x))
  | `Node (pos, [ value, x ]) ->
      (match make_branches x with
         `Branch (l2, x2) -> `Branch (((pos, value) :: l2), x2)
       | x -> `Branch ([pos, value], x))
  | `Node (pos, l) ->
      `Node (pos, List.map (fun (value, x) -> (value, make_branches x)) l)


let make_initial_tree l : 'a tree =
  let rec aux i = function
      [] -> assert false
    | [ (s, x) ] ->
        let pos =
          if i < String.length s then `Position i
          else `End
        in
        make_end_branch s pos x

    | ((s, _) :: _) as l ->
        if i < String.length s then
          let groups = group_by (fun (s, _) -> `Char s.[i]) l in
          `Node (`Position i,
                 List.map (fun (k, l) -> (k, aux (i+1) l)) groups)
        else
          (* reached end of string but multiple strings remain *)
          invalid_arg (sprintf "String_match.make_tree: duplicate key %S" s)
  in
  match l with
    [] -> `Node (`Length, [])
  | [ (s, x) ] -> make_end_branch s `Length x
  | l ->
      let groups = group_by (fun (s, _) -> `Int (String.length s)) l in
      `Node (`Length,
             List.map (fun (k, l) -> (k, aux 0 l)) groups)

let make_tree l =
  make_branches (make_initial_tree l)



let test () =
  let l = [
    "abcdeg";
    "abcdef";
    "abdefh";
    "bcd";
    "";
  ]
  in
  make_tree (List.map (fun s -> (s, s)) l)


let get_value string_id pos_id pos =
  match pos with
    `Length -> "len"
  | `Position i ->
      if i = 0 then
        sprintf "String.unsafe_get %s %s" string_id pos_id
      else
        sprintf "String.unsafe_get %s (%s+%i)" string_id pos_id i
  | `End -> assert false

let make_pattern value =
  match value with
    `Int i -> string_of_int i
  | `Char c -> sprintf "%C" c

let cond test if_true if_false =
  [
    Line (sprintf "if %s then (" test);
    Block if_true;
    Line ")";
    Line "else (";
    Block if_false;
    Line ")";
  ]

let make_branch_test string_id pos_id = function
    (`Length, `Int n) -> sprintf "len = %i" n
  | (`Position i, `Char c) ->
      if i = 0 then
        sprintf "String.unsafe_get %s %s = %C" string_id pos_id c
      else
        sprintf "String.unsafe_get %s (%s+%i) = %C" string_id pos_id i c
  | _ -> assert false

let make_branch_tests string_id pos_id l =
  String.concat " && " (List.map (make_branch_test string_id pos_id) l)

let rec map_to_ocaml string_id pos_id e = function
    `Leaf expr -> expr

  | `Branch (l, x) ->
      cond (make_branch_tests string_id pos_id l)
        (map_to_ocaml string_id pos_id e x)
        e

  | `Node (pos, l) ->
      [
        Line (sprintf "match %s with" (get_value string_id pos_id pos));
        Block [
          Inline (List.map (make_case string_id pos_id e) l);
          Line "| _ -> (";
          Block [
            Block e;
            Line ")";
          ];
        ]
      ]

and make_case string_id pos_id e (value, tree) =
  Inline [
    Line (sprintf "| %s -> (" (make_pattern value));
    Block [
      Block (map_to_ocaml string_id pos_id e tree);
      Line ")";
    ];
  ]


type exit_with =
  [ `Exn of string
  | `Expr ]

let make_ocaml_expr_factored
    ?(string_id = "s")
    ?(pos_id = "pos")
    ?(exit_with = `Exn "Exit")
    ~error_expr
    cases : Indent.t list =

  let exit_expr, catch =
    match exit_with with
      `Expr -> error_expr, (fun x -> x)
    | `Exn error_exn ->
        let exit_expr = [ Line (sprintf "raise (%s)" error_exn) ] in
        let catch x =
          [
            Line "try";
            Block x;
            Line (sprintf "with %s -> (" error_exn);
            Block [
              Block error_expr;
              Line ")";
            ];
          ]
        in
        exit_expr, catch
  in
  match cases with
    [] -> error_expr
  | _ ->
      catch (map_to_ocaml string_id pos_id exit_expr (make_tree cases))

let test2 () =
  let l = [
    "abc";
    "abcd";
    "abde";
    "bcd";
    "";
  ]
  in
  let cases =
    List.map
      (fun s -> (s, [ Line (sprintf "Some `Case_%s" s) ]))
      l
  in
  let expr =
    make_ocaml_expr_factored
      ~error_expr:[ Line "None" ]
      cases
  in
  Indent.to_stdout (List.map Indent.strip expr)


let make_ocaml_expr_naive
    ?(string_id = "s")
    ~error_expr
    cases =
  let map (s, expr) =
    Inline [
      Line (sprintf "| %S ->" s);
      Block expr;
    ]
  in
  [
    Line (sprintf "match %s with" string_id);
    Block [
      Inline (List.map map cases);
      Line "| _ ->";
      Block error_expr;
    ]
  ]


let make_ocaml_expr
    ~optimized
    ?string_id
    ?pos_id
    ?exit_with
    ~error_expr
    cases : Indent.t list =

  if optimized then
    make_ocaml_expr_factored
      ?string_id ?pos_id ?exit_with ~error_expr cases
  else
    make_ocaml_expr_naive
      ?string_id ~error_expr cases


let make_ocaml_int_mapping
    ?(string_id = "s")
    ?(pos_id = "pos")
    ?(len_id = "len")
    ?exit_with
    ~error_expr1
    ?(error_expr2 = [ Line "assert false" ])
    ?(int_id = "i")
    cases : Indent.t list * Indent.t list =

  let a = Array.of_list cases in
  let int_cases =
    Array.mapi (fun i (s, _) -> (s, [ Line (string_of_int i) ])) a
  in
  let int_mapping_body =
    make_ocaml_expr_factored
      ~string_id
      ~pos_id
      ?exit_with
      ~error_expr: error_expr1
      (Array.to_list int_cases)
  in
  let int_mapping_function =
    [
      Line (sprintf "fun %s %s %s ->" string_id pos_id len_id);
      Block [
        Line (
          sprintf "if %s < 0 || %s < 0 || %s + %s > String.length %s then"
            pos_id len_id pos_id len_id string_id
        );
        Block [
          Line "invalid_arg \"out-of-bounds substring position or length\";";
        ];
        Inline int_mapping_body;
      ];
    ]
  in
  let int_matching_cases =
    Array.mapi (
      fun i (_, x) ->
        Inline [
          Line (sprintf "| %i ->" i);
          Block x;
        ]
    ) a
  in
  let int_matching =
    [
      Line (sprintf "match %s with" int_id);
      Block [
        Inline (Array.to_list int_matching_cases);
        Line "| _ -> (";
        Block [
          Block error_expr2;
          Line ")";
        ];
      ];
    ]
  in
  int_mapping_function, int_matching
atd-2.1.0/atdgen/src/string_match.mli000066400000000000000000000044061357165332000175110ustar00rootroot00000000000000(**
   Compilation of string pattern matching into something faster than
   what ocamlopt does.
*)

type position = [ `Length | `Position of int | `End ]
type value = [ `Int of int | `Char of char ]

type 'a tree =
    [ `Node of (position * (value * 'a tree) list)
    | `Branch of ((position * value) list * 'a tree)
    | `Leaf of 'a ]

val make_tree : (string * 'a) list -> 'a tree

type exit_with =
    [ `Exn of string
    | `Expr ]
      (** [`Exn s] raises an exception for each failure branch, and this
          exception is caught in one place, avoiding duplication of the
          [error_expr] expression.

          [`Expr] uses the [error_expr] in each failure branch,
          resulting in code duplication but avoiding raising and
          catching an exception. Suitable for fixed-length values
          for which code duplication is tolerable.
      *)

val make_ocaml_expr_factored :
  ?string_id: string ->
  ?pos_id: string ->
  ?exit_with: exit_with ->
  error_expr: Indent.t list ->
  (string * Indent.t list) list -> Indent.t list

val make_ocaml_expr_naive :
  ?string_id: string ->
  error_expr: Indent.t list ->
  (string * Indent.t list) list -> Indent.t list

val make_ocaml_expr :
  optimized: bool ->
  ?string_id: string ->
  ?pos_id: string ->
  ?exit_with: exit_with ->
  error_expr: Indent.t list ->
  (string * Indent.t list) list -> Indent.t list


val make_ocaml_int_mapping :
  ?string_id: string ->
  ?pos_id: string ->
  ?len_id: string ->
  ?exit_with: exit_with ->
  error_expr1: Indent.t list ->
  ?error_expr2: Indent.t list ->
  ?int_id: string ->
  (string * Indent.t list) list ->

  (Indent.t list * Indent.t list)
    (*
      takes a list of cases, each being defined by a string to match against
      and by a corresponding expression of type 'a.

      returns:
      - function expression of type string -> int -> int -> int
        (maps a substring to an int corresponding to one of the strings
        to match against)

      - match-with expression of type 'a
        (matches s against the ints corresponding to the strings to match
        against)

      The whole point is to read records or variants without
      creating new strings or closures.
    *)

val test : unit -> string tree
val test2 : unit -> unit
(** For internal use only *)
atd-2.1.0/atdgen/src/validate.ml000066400000000000000000000027721357165332000164530ustar00rootroot00000000000000(*
  Mapping from ATD to "validate"
*)

open Atd.Import

type validate_repr = (string option * bool)
    (* (opt_v, b)
       is obtained by analyzing all available type definitions.
       The first value opt_v is the optional local validator
       coming from an ATD annotation (see `Local).
       The second value b is true iff the data doesn't need scanning.

       There are four cases:
       opt_v = None && b = true => no validation is needed at all
       opt_v = None && b = false => validators must be called on some
                                    sub-fields of the data
       opt_v <> None && b = true => the given validator must be called
                                    but there's no need to look into
                                    the sub-fields
       opt_v <> None && b = false => the given validator must be called
                                     in addition to scanning sub-fields
    *)

let make_full_validator s =
  sprintf "\
  fun path x ->
    let msg = \"Failed check by %s\" in
    if (%s) x then
      None
    else
      Some (Atdgen_runtime.Util.Validation.error ~msg path)"
    (String.escaped s) s

let get_validator an =
  let full =
    Atd.Annot.get_opt_field
      ~parse:(fun s -> Some s)
      ~sections:["ocaml"]
      ~field:"validator"
      an
  in
  match full with
  | Some _ -> full
  | None ->
      Atd.Annot.get_opt_field
        ~parse:(fun s -> Some s)
        ~sections:["ocaml"]
        ~field:"valid"
        an
      |> Option.map make_full_validator
atd-2.1.0/atdgen/src/validate.mli000066400000000000000000000002241357165332000166120ustar00rootroot00000000000000(** ATD annotations relating to OCaml validators. *)

type validate_repr = (string option * bool)

val get_validator : Atd.Annot.t -> string option
atd-2.1.0/atdgen/src/version.ml000066400000000000000000000000341357165332000163340ustar00rootroot00000000000000let version = "%%VERSION%%"
atd-2.1.0/atdgen/src/xb_emit.ml000066400000000000000000000100441357165332000163000ustar00rootroot00000000000000(*
  Tools shared between code generators for the biniou serialization format.
  (xb means X-Biniou)
*)

open Atd.Import
open Mapping

type 'a expr = ('a, Biniou.biniou_repr) Mapping.mapping
type 'a def = ('a, Biniou.biniou_repr) Mapping.def
type 'a grouped_defs = (bool * 'a def list) list

type name = (loc * string)

type names = {
  field_names : name list list;
  variant_names : name list list;
}

let rec extract_names_from_expr acc (x : 'a expr) =
  match x with
    Unit _
  | Bool _
  | Int _
  | Float  _
  | String _ -> acc
  | Sum (_, va, _, _) ->
      let l, (fn, vn) =
        Array.fold_left extract_names_from_variant ([], acc) va
      in
      (fn, List.rev l :: vn)

  | Record (_, fa, _, _) ->
      let l, (fn, vn) =
        Array.fold_left extract_names_from_field ([], acc) fa
      in
      (List.rev l :: fn, vn)

  | Tuple (_, ca, _, _) ->
      Array.fold_left extract_names_from_cell acc ca

  | List (_, x, _, _)
  | Option (_, x, _, _)
  | Nullable (_, x, _, _)
  | Wrap (_, x, _, _) ->
      extract_names_from_expr acc x

  | Name (_, _, l, _, _) ->
      List.fold_left extract_names_from_expr acc l

  | External (_, _, l, _, _) ->
      List.fold_left extract_names_from_expr acc l

  | Tvar _ -> acc

and extract_names_from_variant (l, acc) x =
  let l = (x.var_loc, x.var_cons) :: l in
  match x.var_arg with
      None -> (l, acc)
    | Some x ->
        (l, extract_names_from_expr acc x)

and extract_names_from_field (l, acc) x =
  let l = (x.f_loc, x.f_name) :: l in
  (l, extract_names_from_expr acc x.f_value)

and extract_names_from_cell acc x =
  extract_names_from_expr acc x.cel_value


let extract_ocaml_names_from_defs l =
  let fn, vn =
    List.fold_left (
      fun acc def ->
        match def.def_value with
            None -> acc
          | Some x -> extract_names_from_expr acc x
    ) ([], []) l
  in
  {
    field_names = List.rev fn;
    variant_names = List.rev vn;
  }

let check_duplicate_hashes kind l =
  let tbl = Hashtbl.create 100 in
  List.iter (
    fun (loc, s) ->
      let h = Bi_io.hash_name s in
      try
        let loc0, s0 = Hashtbl.find tbl h in
        Error.error2
          loc0 (sprintf "Definition of %s %s." kind s0)
          loc (
            sprintf "\
Definition of %s %s.

Both %s and %s have the same hash %i which
makes them indistinguishable once in the Biniou format.
Use different names."
              kind s
              s0 s h
          )

      with Not_found ->
        Hashtbl.add tbl h (loc, s)
  ) l

let check_hashes x =
  List.iter (check_duplicate_hashes "record field name") x.field_names;
  List.iter (check_duplicate_hashes "variant name") x.variant_names

let check (l : 'a grouped_defs) =
  extract_ocaml_names_from_defs (List.concat_map snd l)
  |> check_hashes

(*
let find_clashes () =
  let l = Mikmatch.Text.lines_of_file "/tmp/dictionary.txt" in
(*
  let l1 = List.rev_map (fun s -> s ^ "1") l in
  let l2 = List.rev_map (fun s -> s ^ "2") l in
  let l3 = List.rev_map (fun s -> s ^ "3") l in
  let l4 = List.rev_map (fun s -> s ^ "4") l in
  let l = List.flatten [l; l1; l2; l3; l4] in
*)
  let tbl = Hashtbl.create (2 * List.length l) in
  List.iter (
    fun s ->
      let h = Bi_io.hash_name s in
      let r =
        try Hashtbl.find tbl h
        with Not_found ->
          let r = ref [] in
          Hashtbl.add tbl h r;
          r
      in
      r := s :: !r
  ) l;
  let clashes =
    Hashtbl.fold (
      fun h r acc ->
        let l = !r in
        if List.length l >= 2 then
        List.rev l :: acc
        else
          acc
    ) tbl []
  in
  let clashes = List.sort compare clashes in
  List.iter (fun l -> print_endline (String.concat " " l)) clashes
*)

(*
Groups of words with identical biniou hashes obtained with find_clashes:

bind1 classroom's3
bind2 classroom's4
commutes1 funerals4
expect1 tantalus4
idea chaw2
interval's1 middling2
interval's2 middling3
interval's3 middling4
militarily1 scheduled4
overviews neglects3
shea crew2
vacating maxine3
workshop1 examples3
workshop2 examples4

bevel reconveyed
cogitate jutties
premiums squigglier
representationalists supervene
*)
atd-2.1.0/atdgen/src/xb_emit.mli000066400000000000000000000003371357165332000164550ustar00rootroot00000000000000(** Utilities for writing code generators for Biniou from a decorated
    ATD AST. *)

type 'a def = ('a, Biniou.biniou_repr) Mapping.def
type 'a grouped_defs = (bool * 'a def list) list

val check : _ grouped_defs -> unit
atd-2.1.0/atdgen/test/000077500000000000000000000000001357165332000145105ustar00rootroot00000000000000atd-2.1.0/atdgen/test/array_wrap.ml000066400000000000000000000001111357165332000172020ustar00rootroot00000000000000type 'a t = 'a array
let wrap = Array.of_list
let unwrap = Array.to_list
atd-2.1.0/atdgen/test/benchmark.ml000066400000000000000000000107431357165332000170010ustar00rootroot00000000000000
open Printf

(*** Type definitions for json-static ***)

open Test

module C =
struct
  type t = char
  let to_json x = Json_type.Int (Char.code x)
  let of_json = function
      Json_type.Int i when i >= 0 && i < 256 -> (Char.chr i)
    | _ -> failwith "corrupted json char"
  let t = `Int
end

module I32 =
struct
  type t = int32
  let to_json x = Json_type.String (Int32.to_string x)
  let of_json = function
      Json_type.String s -> (Int32.of_string s)
    | _ -> failwith "corrupted json int32"
  let t = `String
end

module I64 =
struct
  type t = int64
  let to_json x = Json_type.String (Int64.to_string x)
  let of_json = function
      Json_type.String s -> (Int64.of_string s)
    | _ -> failwith "corrupted json int64"
  let t = `String
end

let json_of_unit () = Json_type.Null
let unit_of_json = function
    Json_type.Null -> ()
  | _ -> failwith "error: expected null"

type json test_variant = predefined
    [ `Case1 | `Case2 of int | `Case3 of string | `Case4 of test_variant list ]

and mixed_record = predefined {
  ?field0 : int option;
  ?field1 : float option;
  field2 : string option;
  field3 : I64.t;
  field4 : float array;
  ?field5 : bool option;
  ?field6 : string option;
  field7 : test_variant;
  field8 : string array;
  field9 : (
    int
    * int
    * C.t
    * int
    * I32.t
    * I64.t
  );
  field10 : bool;
  ?field11 : bool = false;
  field12 : unit list;
  field13 : string option list
}

and mixed = (mixed_record array * mixed_record array) list



(*** Creation of sample data for testing ***)

let make_mixed_record_array n =
  Array.init n (fun i ->
    {
      field0 = Some i;
      field1 = Some 0.555;
      field2 = Some (String.copy "abcdefghijklmnopqrstuvwxyz");
      field3 = 12345678L;
      field4 = [| 1.23; 3.45; 4.56 |];
      field5 = None;
      field6 = None;
      field7 = `Case4 [ `Case1; `Case2 999; `Case3 "abcdefghij"; `Case4 [] ];
      field8 = [| "a"; "bc"; "def"; "ghij"; "klmno";
                  "pqrstu"; "vwxyz01"; "23456789" |];
      field9 = (
        1_000_000,
        0xff,
        '\xff',
        0xffff,
        0xffffffffl,
        0xffffffffffffffffL
      );
      field10 = true;
      field11 = false;
      field12 = [ (); () ];
      field13 = [ Some "abcdefgh"; None; Some "qwerty" ]
    }
  )

let make_mixed ~top_len ~tab_len ~ar_len =
  List.init top_len (fun _ ->
    (make_mixed_record_array tab_len, make_mixed_record_array ar_len)
  )


(*** Benchmarking ***)

let time s f x =
  printf "%s: %!" s;
  let t1 = Unix.gettimeofday () in
  let y = f x in
  let t2 = Unix.gettimeofday () in
  printf "%.3f s\n%!" (t2 -. t1);
  y

let print_length label s =
  printf "%s len = %i\n" label (String.length s)

let marshal_mixed x =
  let s = Marshal.to_string x [Marshal.No_sharing] in
  print_length "marshal" s;
  s

let unmarshal_mixed s =
  (Marshal.from_string s 0 : mixed)

let jsonstatic_of_mixed x =
  let s = Json_io.string_of_json ~compact:true (json_of_mixed x) in
  print_length "json-static" s;
  s

let mixed_of_jsonstatic s =
  mixed_of_json (Json_io.json_of_string s)

let biniou_of_mixed x =
  let s = Test.string_of_mixed ~len:10_000_000 x in
  print_length "atdgen-biniou" s;
  s

let mixed_of_biniou s =
  Test.mixed_of_string s

let atdgenjson_of_mixed x =
  let s = Testj.string_of_mixed ~len:10_000_000 x in
  print_length "atdgen-json" s;
  s

let mixed_of_atdgenjson s =
  Testj.mixed_of_string s

let compact () =
  printf "[compaction]\n%!";
  Gc.compact ()

let single_perf_test () =
  let x = make_mixed ~top_len:100 ~tab_len:500 ~ar_len:500 in
  if true then (
    compact ();
    let marshal_s = time "marshal write" marshal_mixed x in
    compact ();
    ignore (time "marshal read" unmarshal_mixed marshal_s);
  );
  if true then (
    compact ();
    let biniou_s = time "atdgen-biniou write" biniou_of_mixed x in
    compact ();
    ignore (time "atdgen-biniou read" mixed_of_biniou biniou_s);
  );
  if true then (
    compact ();
    let json_s = time "atdgen-json write" atdgenjson_of_mixed x in
    compact ();
    ignore (time "atdgen-json read" mixed_of_atdgenjson json_s);
  );
  if true then (
    compact ();
    let json_s = time "json-static write" jsonstatic_of_mixed x in
    compact ();
    ignore (time "json-static read" mixed_of_jsonstatic json_s);
  )

let perf_test () =
  Gc.set { (Gc.get()) with Gc.verbose = 0x020 };
  let n = 2 in
  for i = 1 to n do
    printf "[run %i/%i]\n%!" i n;
    if i = 2 then
      Gc.set { (Gc.get()) with Gc.space_overhead = 500 };
    single_perf_test ()
  done


let () = perf_test ()
atd-2.1.0/atdgen/test/bucklescript/000077500000000000000000000000001357165332000172025ustar00rootroot00000000000000atd-2.1.0/atdgen/test/bucklescript/a_bs.ml000066400000000000000000000003771357165332000204470ustar00rootroot00000000000000let write_from_module_a =
  Atdgen_codec_runtime.Encode.make (function
    | A_t.Foo -> `String "Foo"
    | Bar -> `String "Bar")

let read_from_module_a =
  Atdgen_codec_runtime.Decode.enum
    [ "Foo", `Single A_t.Foo
    ; "Bar", `Single A_t.Bar
    ]
atd-2.1.0/atdgen/test/bucklescript/a_j.ml000066400000000000000000000001331357165332000202620ustar00rootroot00000000000000let write_from_module_a _ _ = ()
let read_from_module_a _lexer_state _lexbuf = failwith ""
atd-2.1.0/atdgen/test/bucklescript/a_t.ml000066400000000000000000000000451357165332000202760ustar00rootroot00000000000000type from_module_a =
  | Foo
  | Bar
atd-2.1.0/atdgen/test/bucklescript/bucklespec.atd000066400000000000000000000031301357165332000220110ustar00rootroot00000000000000
type label = string

type valid = bool

type labeled =
  { flag: valid
  ; lb: label
  ; count: int
  }

type point = (int * int * string * unit)

type 'a param =
  { data: 'a
  ; nothing: unit
  }

type 'a param_similar =
  { data: 'a
  ; something: int
  }

type 'a same_pair = ('a * 'a)

type ('a, 'b) pair =
  { left: 'a
  ; right: 'b
  }


type 'a pairs = ('a, 'a) pair list

type id = string  wrap
    failwith \"empty\"
                       | _ -> None">

type 'a simple_var =
  [ Foo of (int * int)
  | Bar
  | Foobar of 'a
  | Foo_id of id
  ]

type simple_vars = unit simple_var list

type v1 =
 [ V1_foo of bool
 | V2_bar of int
 ] 

type v2 =
 [ V1_foo of int
 | V2_bar of bool
 ] 

type from_module_a  = abstract

type record_json_name =
  { foo  : int
  }

type single_tuple = [ Single_tuple of (int) ]

(*** Test json adapters ***)

type adapted = [
  | A of a
  | B of b
] 

type a = {
  thing: string;
  other_thing: bool;
}

type b = {
  thing: int;
}

type recurse = {
  recurse_items: recurse list;
}

type mutual_recurse1 = {
  mutual_recurse2: mutual_recurse2;
}

type mutual_recurse2 = {
  mutual_recurse1: mutual_recurse1;
}

type using_object = {
   f : (string * int) list ;
 }
atd-2.1.0/atdgen/test/bucklescript/bucklespec_bs.expected.ml000066400000000000000000000445551357165332000241550ustar00rootroot00000000000000(* Auto-generated from "bucklespec.atd" *)
              [@@@ocaml.warning "-27-32-35-39"]

type recurse = Bucklespec_t.recurse = { recurse_items: recurse list }

type mutual_recurse1 = Bucklespec_t.mutual_recurse1 = {
  mutual_recurse2: mutual_recurse2
}

and mutual_recurse2 = Bucklespec_t.mutual_recurse2 = {
  mutual_recurse1: mutual_recurse1
}

type valid = Bucklespec_t.valid

type v2 = Bucklespec_t.v2 =  V1_foo of int | V2_bar of bool 

type v1 = Bucklespec_t.v1 =  V1_foo of bool | V2_bar of int 

type using_object = Bucklespec_t.using_object = { f: (string * int) list }

type single_tuple = Bucklespec_t.single_tuple

type id = Bucklespec_t.id

type 'a simple_var = 'a Bucklespec_t.simple_var

type simple_vars = Bucklespec_t.simple_vars

type 'a same_pair = 'a Bucklespec_t.same_pair

type record_json_name = Bucklespec_t.record_json_name = { foo: int }

type point = Bucklespec_t.point

type 'a param_similar = 'a Bucklespec_t.param_similar = {
  data: 'a;
  something: int
}

type 'a param = 'a Bucklespec_t.param = { data: 'a; nothing: unit }

type ('a, 'b) pair = ('a, 'b) Bucklespec_t.pair = { left: 'a; right: 'b }

type 'a pairs = 'a Bucklespec_t.pairs

type label = Bucklespec_t.label

type labeled = Bucklespec_t.labeled = { flag: valid; lb: label; count: int }

type from_module_a = A_t.from_module_a

type b = Bucklespec_t.b = { thing: int }

type a = Bucklespec_t.a = { thing: string; other_thing: bool }

type adapted = Bucklespec_t.adapted

let rec write_mutual_recurse1 js = (
  Atdgen_codec_runtime.Encode.make (fun (t : mutual_recurse1) ->
    (
    Atdgen_codec_runtime.Encode.obj
      [
          Atdgen_codec_runtime.Encode.field
            (
            write_mutual_recurse2
            )
          ~name:"mutual_recurse2"
          t.mutual_recurse2
      ]
    )
  )
) js
and write_mutual_recurse2 js = (
  Atdgen_codec_runtime.Encode.make (fun (t : mutual_recurse2) ->
    (
    Atdgen_codec_runtime.Encode.obj
      [
          Atdgen_codec_runtime.Encode.field
            (
            write_mutual_recurse1
            )
          ~name:"mutual_recurse1"
          t.mutual_recurse1
      ]
    )
  )
) js
let rec read_mutual_recurse1 js = (
  Atdgen_codec_runtime.Decode.make (fun json ->
    (
      ({
          mutual_recurse2 =
            Atdgen_codec_runtime.Decode.decode
            (
              read_mutual_recurse2
              |> Atdgen_codec_runtime.Decode.field "mutual_recurse2"
            ) json;
      } : mutual_recurse1)
    )
  )
) js
and read_mutual_recurse2 js = (
  Atdgen_codec_runtime.Decode.make (fun json ->
    (
      ({
          mutual_recurse1 =
            Atdgen_codec_runtime.Decode.decode
            (
              read_mutual_recurse1
              |> Atdgen_codec_runtime.Decode.field "mutual_recurse1"
            ) json;
      } : mutual_recurse2)
    )
  )
) js
let rec write__5 js = (
  Atdgen_codec_runtime.Encode.list (
    write_recurse
  )
) js
and write_recurse js = (
  Atdgen_codec_runtime.Encode.make (fun (t : recurse) ->
    (
    Atdgen_codec_runtime.Encode.obj
      [
          Atdgen_codec_runtime.Encode.field
            (
            write__5
            )
          ~name:"recurse_items"
          t.recurse_items
      ]
    )
  )
) js
let rec read__5 js = (
  Atdgen_codec_runtime.Decode.list (
    read_recurse
  )
) js
and read_recurse js = (
  Atdgen_codec_runtime.Decode.make (fun json ->
    (
      ({
          recurse_items =
            Atdgen_codec_runtime.Decode.decode
            (
              read__5
              |> Atdgen_codec_runtime.Decode.field "recurse_items"
            ) json;
      } : recurse)
    )
  )
) js
let write_valid = (
  Atdgen_codec_runtime.Encode.bool
)
let read_valid = (
  Atdgen_codec_runtime.Decode.bool
)
let write_v2 = (
  Atdgen_codec_runtime.Encode.make (fun (x : v2) -> match x with
    | V1_foo x ->
    Atdgen_codec_runtime.Encode.constr1 "V1_foo" (
      Atdgen_codec_runtime.Encode.int
    ) x
    | V2_bar x ->
    Atdgen_codec_runtime.Encode.constr1 "V2_bar" (
      Atdgen_codec_runtime.Encode.bool
    ) x
  )
)
let read_v2 = (
  Atdgen_codec_runtime.Decode.enum
  [
      (
      "V1_foo"
      ,
        `Decode (
        Atdgen_codec_runtime.Decode.int
        |> Atdgen_codec_runtime.Decode.map (fun x -> ((V1_foo x) : v2))
        )
      )
    ;
      (
      "V2_bar"
      ,
        `Decode (
        Atdgen_codec_runtime.Decode.bool
        |> Atdgen_codec_runtime.Decode.map (fun x -> ((V2_bar x) : v2))
        )
      )
  ]
)
let write_v1 = (
  Atdgen_codec_runtime.Encode.make (fun (x : v1) -> match x with
    | V1_foo x ->
    Atdgen_codec_runtime.Encode.constr1 "V1_foo" (
      Atdgen_codec_runtime.Encode.bool
    ) x
    | V2_bar x ->
    Atdgen_codec_runtime.Encode.constr1 "V2_bar" (
      Atdgen_codec_runtime.Encode.int
    ) x
  )
)
let read_v1 = (
  Atdgen_codec_runtime.Decode.enum
  [
      (
      "V1_foo"
      ,
        `Decode (
        Atdgen_codec_runtime.Decode.bool
        |> Atdgen_codec_runtime.Decode.map (fun x -> ((V1_foo x) : v1))
        )
      )
    ;
      (
      "V2_bar"
      ,
        `Decode (
        Atdgen_codec_runtime.Decode.int
        |> Atdgen_codec_runtime.Decode.map (fun x -> ((V2_bar x) : v1))
        )
      )
  ]
)
let write__6 = (
  Atdgen_codec_runtime.Encode.make (fun (t : _) ->
    t |>
    List.map (
      fun (key, value) ->
        Atdgen_codec_runtime.Encode.field
          (
            Atdgen_codec_runtime.Encode.int
          )
          ~name:key
          value
    ) |>
    Atdgen_codec_runtime.Encode.obj
  )
)
let read__6 = (
  Atdgen_codec_runtime.Decode.obj_list (
    Atdgen_codec_runtime.Decode.int
  )
)
let write_using_object = (
  Atdgen_codec_runtime.Encode.make (fun (t : using_object) ->
    (
    Atdgen_codec_runtime.Encode.obj
      [
          Atdgen_codec_runtime.Encode.field
            (
            write__6
            )
          ~name:"f"
          t.f
      ]
    )
  )
)
let read_using_object = (
  Atdgen_codec_runtime.Decode.make (fun json ->
    (
      ({
          f =
            Atdgen_codec_runtime.Decode.decode
            (
              read__6
              |> Atdgen_codec_runtime.Decode.field "f"
            ) json;
      } : using_object)
    )
  )
)
let write_single_tuple = (
  Atdgen_codec_runtime.Encode.make (fun (x : _) -> match x with
    | `Single_tuple x ->
    Atdgen_codec_runtime.Encode.constr1 "Single_tuple" (
      Atdgen_codec_runtime.Encode.tuple1
        (
          Atdgen_codec_runtime.Encode.int
        )
    ) x
  )
)
let read_single_tuple = (
  Atdgen_codec_runtime.Decode.enum
  [
      (
      "Single_tuple"
      ,
        `Decode (
        Atdgen_codec_runtime.Decode.tuple1
          (
            Atdgen_codec_runtime.Decode.int
          )
        |> Atdgen_codec_runtime.Decode.map (fun x -> ((`Single_tuple x) : _))
        )
      )
  ]
)
let write__2 = (
    Atdgen_codec_runtime.Encode.string
  |> Atdgen_codec_runtime.Encode.contramap (function `Id s -> s)
)
let read__2 = (
  (
    Atdgen_codec_runtime.Decode.string
  ) |> (Atdgen_codec_runtime.Decode.map (fun s -> `Id s))
)
let write_id = (
  write__2
)
let read_id = (
  read__2
)
let write__3 = (
  Atdgen_codec_runtime.Encode.make (fun (x : _) -> match x with
    | `Foo x ->
    Atdgen_codec_runtime.Encode.constr1 "Foo" (
      Atdgen_codec_runtime.Encode.tuple2
        (
          Atdgen_codec_runtime.Encode.int
        )
        (
          Atdgen_codec_runtime.Encode.int
        )
    ) x
    | `Bar ->
    Atdgen_codec_runtime.Encode.constr0 "Bar"
    | `Foobar x ->
    Atdgen_codec_runtime.Encode.constr1 "Foobar" (
      Atdgen_codec_runtime.Encode.unit
    ) x
    | `Foo_id x ->
    Atdgen_codec_runtime.Encode.constr1 "Foo_id" (
      write_id
    ) x
  )
)
let read__3 = (
  Atdgen_codec_runtime.Decode.enum
  [
      (
      "Foo"
      ,
        `Decode (
        Atdgen_codec_runtime.Decode.tuple2
          (
            Atdgen_codec_runtime.Decode.int
          )
          (
            Atdgen_codec_runtime.Decode.int
          )
        |> Atdgen_codec_runtime.Decode.map (fun x -> ((`Foo x) : _))
        )
      )
    ;
      (
      "Bar"
      ,
        `Single (`Bar)
      )
    ;
      (
      "Foobar"
      ,
        `Decode (
        Atdgen_codec_runtime.Decode.unit
        |> Atdgen_codec_runtime.Decode.map (fun x -> ((`Foobar x) : _))
        )
      )
    ;
      (
      "Foo_id"
      ,
        `Decode (
        read_id
        |> Atdgen_codec_runtime.Decode.map (fun x -> ((`Foo_id x) : _))
        )
      )
  ]
)
let write__4 = (
  Atdgen_codec_runtime.Encode.list (
    write__3
  )
)
let read__4 = (
  Atdgen_codec_runtime.Decode.list (
    read__3
  )
)
let write_simple_vars = (
  write__4
)
let read_simple_vars = (
  read__4
)
let write_simple_var write__a = (
  Atdgen_codec_runtime.Encode.make (fun (x : _) -> match x with
    | `Foo x ->
    Atdgen_codec_runtime.Encode.constr1 "Foo" (
      Atdgen_codec_runtime.Encode.tuple2
        (
          Atdgen_codec_runtime.Encode.int
        )
        (
          Atdgen_codec_runtime.Encode.int
        )
    ) x
    | `Bar ->
    Atdgen_codec_runtime.Encode.constr0 "Bar"
    | `Foobar x ->
    Atdgen_codec_runtime.Encode.constr1 "Foobar" (
      write__a
    ) x
    | `Foo_id x ->
    Atdgen_codec_runtime.Encode.constr1 "Foo_id" (
      write_id
    ) x
  )
)
let read_simple_var read__a = (
  Atdgen_codec_runtime.Decode.enum
  [
      (
      "Foo"
      ,
        `Decode (
        Atdgen_codec_runtime.Decode.tuple2
          (
            Atdgen_codec_runtime.Decode.int
          )
          (
            Atdgen_codec_runtime.Decode.int
          )
        |> Atdgen_codec_runtime.Decode.map (fun x -> ((`Foo x) : _))
        )
      )
    ;
      (
      "Bar"
      ,
        `Single (`Bar)
      )
    ;
      (
      "Foobar"
      ,
        `Decode (
        read__a
        |> Atdgen_codec_runtime.Decode.map (fun x -> ((`Foobar x) : _))
        )
      )
    ;
      (
      "Foo_id"
      ,
        `Decode (
        read_id
        |> Atdgen_codec_runtime.Decode.map (fun x -> ((`Foo_id x) : _))
        )
      )
  ]
)
let write_same_pair write__a = (
  Atdgen_codec_runtime.Encode.tuple2
    (
      write__a
    )
    (
      write__a
    )
)
let read_same_pair read__a = (
  Atdgen_codec_runtime.Decode.tuple2
    (
      read__a
    )
    (
      read__a
    )
)
let write_record_json_name = (
  Atdgen_codec_runtime.Encode.make (fun (t : record_json_name) ->
    (
    Atdgen_codec_runtime.Encode.obj
      [
          Atdgen_codec_runtime.Encode.field
            (
            Atdgen_codec_runtime.Encode.int
            )
          ~name:"bar"
          t.foo
      ]
    )
  )
)
let read_record_json_name = (
  Atdgen_codec_runtime.Decode.make (fun json ->
    (
      ({
          foo =
            Atdgen_codec_runtime.Decode.decode
            (
              Atdgen_codec_runtime.Decode.int
              |> Atdgen_codec_runtime.Decode.field "bar"
            ) json;
      } : record_json_name)
    )
  )
)
let write_point = (
  Atdgen_codec_runtime.Encode.tuple4
    (
      Atdgen_codec_runtime.Encode.int
    )
    (
      Atdgen_codec_runtime.Encode.int
    )
    (
      Atdgen_codec_runtime.Encode.string
    )
    (
      Atdgen_codec_runtime.Encode.unit
    )
)
let read_point = (
  Atdgen_codec_runtime.Decode.tuple4
    (
      Atdgen_codec_runtime.Decode.int
    )
    (
      Atdgen_codec_runtime.Decode.int
    )
    (
      Atdgen_codec_runtime.Decode.string
    )
    (
      Atdgen_codec_runtime.Decode.unit
    )
)
let write_param_similar write__a = (
  Atdgen_codec_runtime.Encode.make (fun (t : 'a param_similar) ->
    (
    Atdgen_codec_runtime.Encode.obj
      [
          Atdgen_codec_runtime.Encode.field
            (
            write__a
            )
          ~name:"data"
          t.data
        ;
          Atdgen_codec_runtime.Encode.field
            (
            Atdgen_codec_runtime.Encode.int
            )
          ~name:"something"
          t.something
      ]
    )
  )
)
let read_param_similar read__a = (
  Atdgen_codec_runtime.Decode.make (fun json ->
    (
      ({
          data =
            Atdgen_codec_runtime.Decode.decode
            (
              read__a
              |> Atdgen_codec_runtime.Decode.field "data"
            ) json;
          something =
            Atdgen_codec_runtime.Decode.decode
            (
              Atdgen_codec_runtime.Decode.int
              |> Atdgen_codec_runtime.Decode.field "something"
            ) json;
      } : 'a param_similar)
    )
  )
)
let write_param write__a = (
  Atdgen_codec_runtime.Encode.make (fun (t : 'a param) ->
    (
    Atdgen_codec_runtime.Encode.obj
      [
          Atdgen_codec_runtime.Encode.field
            (
            write__a
            )
          ~name:"data"
          t.data
        ;
          Atdgen_codec_runtime.Encode.field
            (
            Atdgen_codec_runtime.Encode.unit
            )
          ~name:"nothing"
          t.nothing
      ]
    )
  )
)
let read_param read__a = (
  Atdgen_codec_runtime.Decode.make (fun json ->
    (
      ({
          data =
            Atdgen_codec_runtime.Decode.decode
            (
              read__a
              |> Atdgen_codec_runtime.Decode.field "data"
            ) json;
          nothing =
            Atdgen_codec_runtime.Decode.decode
            (
              Atdgen_codec_runtime.Decode.unit
              |> Atdgen_codec_runtime.Decode.field "nothing"
            ) json;
      } : 'a param)
    )
  )
)
let write_pair write__a write__b = (
  Atdgen_codec_runtime.Encode.make (fun (t : ('a, 'b) pair) ->
    (
    Atdgen_codec_runtime.Encode.obj
      [
          Atdgen_codec_runtime.Encode.field
            (
            write__a
            )
          ~name:"left"
          t.left
        ;
          Atdgen_codec_runtime.Encode.field
            (
            write__b
            )
          ~name:"right"
          t.right
      ]
    )
  )
)
let read_pair read__a read__b = (
  Atdgen_codec_runtime.Decode.make (fun json ->
    (
      ({
          left =
            Atdgen_codec_runtime.Decode.decode
            (
              read__a
              |> Atdgen_codec_runtime.Decode.field "left"
            ) json;
          right =
            Atdgen_codec_runtime.Decode.decode
            (
              read__b
              |> Atdgen_codec_runtime.Decode.field "right"
            ) json;
      } : ('a, 'b) pair)
    )
  )
)
let write__1 write__a write__b = (
  Atdgen_codec_runtime.Encode.list (
    write_pair write__a write__a
  )
)
let read__1 read__a read__b = (
  Atdgen_codec_runtime.Decode.list (
    read_pair read__a read__a
  )
)
let write_pairs write__a = (
  write__1 write__a write__a
)
let read_pairs read__a = (
  read__1 read__a read__a
)
let write_label = (
  Atdgen_codec_runtime.Encode.string
)
let read_label = (
  Atdgen_codec_runtime.Decode.string
)
let write_labeled = (
  Atdgen_codec_runtime.Encode.make (fun (t : labeled) ->
    (
    Atdgen_codec_runtime.Encode.obj
      [
          Atdgen_codec_runtime.Encode.field
            (
            write_valid
            )
          ~name:"flag"
          t.flag
        ;
          Atdgen_codec_runtime.Encode.field
            (
            write_label
            )
          ~name:"lb"
          t.lb
        ;
          Atdgen_codec_runtime.Encode.field
            (
            Atdgen_codec_runtime.Encode.int
            )
          ~name:"count"
          t.count
      ]
    )
  )
)
let read_labeled = (
  Atdgen_codec_runtime.Decode.make (fun json ->
    (
      ({
          flag =
            Atdgen_codec_runtime.Decode.decode
            (
              read_valid
              |> Atdgen_codec_runtime.Decode.field "flag"
            ) json;
          lb =
            Atdgen_codec_runtime.Decode.decode
            (
              read_label
              |> Atdgen_codec_runtime.Decode.field "lb"
            ) json;
          count =
            Atdgen_codec_runtime.Decode.decode
            (
              Atdgen_codec_runtime.Decode.int
              |> Atdgen_codec_runtime.Decode.field "count"
            ) json;
      } : labeled)
    )
  )
)
let write_from_module_a = (
  A_bs.write_from_module_a
)
let read_from_module_a = (
  A_bs.read_from_module_a
)
let write_b = (
  Atdgen_codec_runtime.Encode.make (fun (t : b) ->
    (
    Atdgen_codec_runtime.Encode.obj
      [
          Atdgen_codec_runtime.Encode.field
            (
            Atdgen_codec_runtime.Encode.int
            )
          ~name:"thing"
          t.thing
      ]
    )
  )
)
let read_b = (
  Atdgen_codec_runtime.Decode.make (fun json ->
    (
      ({
          thing =
            Atdgen_codec_runtime.Decode.decode
            (
              Atdgen_codec_runtime.Decode.int
              |> Atdgen_codec_runtime.Decode.field "thing"
            ) json;
      } : b)
    )
  )
)
let write_a = (
  Atdgen_codec_runtime.Encode.make (fun (t : a) ->
    (
    Atdgen_codec_runtime.Encode.obj
      [
          Atdgen_codec_runtime.Encode.field
            (
            Atdgen_codec_runtime.Encode.string
            )
          ~name:"thing"
          t.thing
        ;
          Atdgen_codec_runtime.Encode.field
            (
            Atdgen_codec_runtime.Encode.bool
            )
          ~name:"other_thing"
          t.other_thing
      ]
    )
  )
)
let read_a = (
  Atdgen_codec_runtime.Decode.make (fun json ->
    (
      ({
          thing =
            Atdgen_codec_runtime.Decode.decode
            (
              Atdgen_codec_runtime.Decode.string
              |> Atdgen_codec_runtime.Decode.field "thing"
            ) json;
          other_thing =
            Atdgen_codec_runtime.Decode.decode
            (
              Atdgen_codec_runtime.Decode.bool
              |> Atdgen_codec_runtime.Decode.field "other_thing"
            ) json;
      } : a)
    )
  )
)
let write_adapted = (
  Atdgen_codec_runtime.Encode.adapter Atdgen_codec_runtime.Json_adapter.Type_field.restore (
    Atdgen_codec_runtime.Encode.make (fun (x : _) -> match x with
      | `A x ->
      Atdgen_codec_runtime.Encode.constr1 "A" (
        write_a
      ) x
      | `B x ->
      Atdgen_codec_runtime.Encode.constr1 "B" (
        write_b
      ) x
    )
  )
)
let read_adapted = (
  Atdgen_codec_runtime.Decode.adapter Atdgen_codec_runtime.Json_adapter.Type_field.normalize (
    Atdgen_codec_runtime.Decode.enum
    [
        (
        "A"
        ,
          `Decode (
          read_a
          |> Atdgen_codec_runtime.Decode.map (fun x -> ((`A x) : _))
          )
        )
      ;
        (
        "B"
        ,
          `Decode (
          read_b
          |> Atdgen_codec_runtime.Decode.map (fun x -> ((`B x) : _))
          )
        )
    ]
  )
)
atd-2.1.0/atdgen/test/bucklescript/bucklespec_bs.expected.mli000066400000000000000000000115001357165332000243060ustar00rootroot00000000000000(* Auto-generated from "bucklespec.atd" *)
              [@@@ocaml.warning "-27-32-35-39"]

type recurse = Bucklespec_t.recurse = { recurse_items: recurse list }

type mutual_recurse1 = Bucklespec_t.mutual_recurse1 = {
  mutual_recurse2: mutual_recurse2
}

and mutual_recurse2 = Bucklespec_t.mutual_recurse2 = {
  mutual_recurse1: mutual_recurse1
}

type valid = Bucklespec_t.valid

type v2 = Bucklespec_t.v2 =  V1_foo of int | V2_bar of bool 

type v1 = Bucklespec_t.v1 =  V1_foo of bool | V2_bar of int 

type using_object = Bucklespec_t.using_object = { f: (string * int) list }

type single_tuple = Bucklespec_t.single_tuple

type id = Bucklespec_t.id

type 'a simple_var = 'a Bucklespec_t.simple_var

type simple_vars = Bucklespec_t.simple_vars

type 'a same_pair = 'a Bucklespec_t.same_pair

type record_json_name = Bucklespec_t.record_json_name = { foo: int }

type point = Bucklespec_t.point

type 'a param_similar = 'a Bucklespec_t.param_similar = {
  data: 'a;
  something: int
}

type 'a param = 'a Bucklespec_t.param = { data: 'a; nothing: unit }

type ('a, 'b) pair = ('a, 'b) Bucklespec_t.pair = { left: 'a; right: 'b }

type 'a pairs = 'a Bucklespec_t.pairs

type label = Bucklespec_t.label

type labeled = Bucklespec_t.labeled = { flag: valid; lb: label; count: int }

type from_module_a = A_t.from_module_a

type b = Bucklespec_t.b = { thing: int }

type a = Bucklespec_t.a = { thing: string; other_thing: bool }

type adapted = Bucklespec_t.adapted

val read_recurse :  recurse Atdgen_codec_runtime.Decode.t

val write_recurse :  recurse Atdgen_codec_runtime.Encode.t

val read_mutual_recurse1 :  mutual_recurse1 Atdgen_codec_runtime.Decode.t

val write_mutual_recurse1 :  mutual_recurse1 Atdgen_codec_runtime.Encode.t

val read_mutual_recurse2 :  mutual_recurse2 Atdgen_codec_runtime.Decode.t

val write_mutual_recurse2 :  mutual_recurse2 Atdgen_codec_runtime.Encode.t

val read_valid :  valid Atdgen_codec_runtime.Decode.t

val write_valid :  valid Atdgen_codec_runtime.Encode.t

val read_v2 :  v2 Atdgen_codec_runtime.Decode.t

val write_v2 :  v2 Atdgen_codec_runtime.Encode.t

val read_v1 :  v1 Atdgen_codec_runtime.Decode.t

val write_v1 :  v1 Atdgen_codec_runtime.Encode.t

val read_using_object :  using_object Atdgen_codec_runtime.Decode.t

val write_using_object :  using_object Atdgen_codec_runtime.Encode.t

val read_single_tuple :  single_tuple Atdgen_codec_runtime.Decode.t

val write_single_tuple :  single_tuple Atdgen_codec_runtime.Encode.t

val read_id :  id Atdgen_codec_runtime.Decode.t

val write_id :  id Atdgen_codec_runtime.Encode.t

val read_simple_var : 'a Atdgen_codec_runtime.Decode.t -> 'a simple_var Atdgen_codec_runtime.Decode.t

val write_simple_var : 'a Atdgen_codec_runtime.Encode.t -> 'a simple_var Atdgen_codec_runtime.Encode.t

val read_simple_vars :  simple_vars Atdgen_codec_runtime.Decode.t

val write_simple_vars :  simple_vars Atdgen_codec_runtime.Encode.t

val read_same_pair : 'a Atdgen_codec_runtime.Decode.t -> 'a same_pair Atdgen_codec_runtime.Decode.t

val write_same_pair : 'a Atdgen_codec_runtime.Encode.t -> 'a same_pair Atdgen_codec_runtime.Encode.t

val read_record_json_name :  record_json_name Atdgen_codec_runtime.Decode.t

val write_record_json_name :  record_json_name Atdgen_codec_runtime.Encode.t

val read_point :  point Atdgen_codec_runtime.Decode.t

val write_point :  point Atdgen_codec_runtime.Encode.t

val read_param_similar : 'a Atdgen_codec_runtime.Decode.t -> 'a param_similar Atdgen_codec_runtime.Decode.t

val write_param_similar : 'a Atdgen_codec_runtime.Encode.t -> 'a param_similar Atdgen_codec_runtime.Encode.t

val read_param : 'a Atdgen_codec_runtime.Decode.t -> 'a param Atdgen_codec_runtime.Decode.t

val write_param : 'a Atdgen_codec_runtime.Encode.t -> 'a param Atdgen_codec_runtime.Encode.t

val read_pair : 'a Atdgen_codec_runtime.Decode.t -> 'b Atdgen_codec_runtime.Decode.t -> ('a, 'b) pair Atdgen_codec_runtime.Decode.t

val write_pair : 'a Atdgen_codec_runtime.Encode.t -> 'b Atdgen_codec_runtime.Encode.t -> ('a, 'b) pair Atdgen_codec_runtime.Encode.t

val read_pairs : 'a Atdgen_codec_runtime.Decode.t -> 'a pairs Atdgen_codec_runtime.Decode.t

val write_pairs : 'a Atdgen_codec_runtime.Encode.t -> 'a pairs Atdgen_codec_runtime.Encode.t

val read_label :  label Atdgen_codec_runtime.Decode.t

val write_label :  label Atdgen_codec_runtime.Encode.t

val read_labeled :  labeled Atdgen_codec_runtime.Decode.t

val write_labeled :  labeled Atdgen_codec_runtime.Encode.t

val read_from_module_a :  from_module_a Atdgen_codec_runtime.Decode.t

val write_from_module_a :  from_module_a Atdgen_codec_runtime.Encode.t

val read_b :  b Atdgen_codec_runtime.Decode.t

val write_b :  b Atdgen_codec_runtime.Encode.t

val read_a :  a Atdgen_codec_runtime.Decode.t

val write_a :  a Atdgen_codec_runtime.Encode.t

val read_adapted :  adapted Atdgen_codec_runtime.Decode.t

val write_adapted :  adapted Atdgen_codec_runtime.Encode.t

atd-2.1.0/atdgen/test/bucklescript/bucklespec_j.expected.ml000066400000000000000000002376761357165332000240120ustar00rootroot00000000000000(* Auto-generated from "bucklespec.atd" *)
[@@@ocaml.warning "-27-32-35-39"]

type recurse = Bucklespec_t.recurse = { recurse_items: recurse list }

type mutual_recurse1 = Bucklespec_t.mutual_recurse1 = {
  mutual_recurse2: mutual_recurse2
}

and mutual_recurse2 = Bucklespec_t.mutual_recurse2 = {
  mutual_recurse1: mutual_recurse1
}

type valid = Bucklespec_t.valid

type v2 = Bucklespec_t.v2 =  V1_foo of int | V2_bar of bool 

type v1 = Bucklespec_t.v1 =  V1_foo of bool | V2_bar of int 

type using_object = Bucklespec_t.using_object = { f: (string * int) list }

type single_tuple = Bucklespec_t.single_tuple

type id = Bucklespec_t.id

type 'a simple_var = 'a Bucklespec_t.simple_var

type simple_vars = Bucklespec_t.simple_vars

type 'a same_pair = 'a Bucklespec_t.same_pair

type record_json_name = Bucklespec_t.record_json_name = { foo: int }

type point = Bucklespec_t.point

type 'a param_similar = 'a Bucklespec_t.param_similar = {
  data: 'a;
  something: int
}

type 'a param = 'a Bucklespec_t.param = { data: 'a; nothing: unit }

type ('a, 'b) pair = ('a, 'b) Bucklespec_t.pair = { left: 'a; right: 'b }

type 'a pairs = 'a Bucklespec_t.pairs

type label = Bucklespec_t.label

type labeled = Bucklespec_t.labeled = { flag: valid; lb: label; count: int }

type from_module_a = A_t.from_module_a

type b = Bucklespec_t.b = { thing: int }

type a = Bucklespec_t.a = { thing: string; other_thing: bool }

type adapted = Bucklespec_t.adapted

let rec write_mutual_recurse1 : _ -> mutual_recurse1 -> _ = (
  fun ob (x : mutual_recurse1) ->
    Bi_outbuf.add_char ob '{';
    let is_first = ref true in
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"mutual_recurse2\":";
    (
      write_mutual_recurse2
    )
      ob x.mutual_recurse2;
    Bi_outbuf.add_char ob '}';
)
and string_of_mutual_recurse1 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_mutual_recurse1 ob x;
  Bi_outbuf.contents ob
and write_mutual_recurse2 : _ -> mutual_recurse2 -> _ = (
  fun ob (x : mutual_recurse2) ->
    Bi_outbuf.add_char ob '{';
    let is_first = ref true in
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"mutual_recurse1\":";
    (
      write_mutual_recurse1
    )
      ob x.mutual_recurse1;
    Bi_outbuf.add_char ob '}';
)
and string_of_mutual_recurse2 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_mutual_recurse2 ob x;
  Bi_outbuf.contents ob
let rec read_mutual_recurse1 = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    Yojson.Safe.read_lcurl p lb;
    let field_mutual_recurse2 = ref (None) in
    try
      Yojson.Safe.read_space p lb;
      Yojson.Safe.read_object_end lb;
      Yojson.Safe.read_space p lb;
      let f =
        fun s pos len ->
          if pos < 0 || len < 0 || pos + len > String.length s then
            invalid_arg "out-of-bounds substring position or length";
          if len = 15 && String.unsafe_get s pos = 'm' && String.unsafe_get s (pos+1) = 'u' && String.unsafe_get s (pos+2) = 't' && String.unsafe_get s (pos+3) = 'u' && String.unsafe_get s (pos+4) = 'a' && String.unsafe_get s (pos+5) = 'l' && String.unsafe_get s (pos+6) = '_' && String.unsafe_get s (pos+7) = 'r' && String.unsafe_get s (pos+8) = 'e' && String.unsafe_get s (pos+9) = 'c' && String.unsafe_get s (pos+10) = 'u' && String.unsafe_get s (pos+11) = 'r' && String.unsafe_get s (pos+12) = 's' && String.unsafe_get s (pos+13) = 'e' && String.unsafe_get s (pos+14) = '2' then (
            0
          )
          else (
            -1
          )
      in
      let i = Yojson.Safe.map_ident p f lb in
      Atdgen_runtime.Oj_run.read_until_field_value p lb;
      (
        match i with
          | 0 ->
            field_mutual_recurse2 := (
              Some (
                (
                  read_mutual_recurse2
                ) p lb
              )
            );
          | _ -> (
              Yojson.Safe.skip_json p lb
            )
      );
      while true do
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_object_sep p lb;
        Yojson.Safe.read_space p lb;
        let f =
          fun s pos len ->
            if pos < 0 || len < 0 || pos + len > String.length s then
              invalid_arg "out-of-bounds substring position or length";
            if len = 15 && String.unsafe_get s pos = 'm' && String.unsafe_get s (pos+1) = 'u' && String.unsafe_get s (pos+2) = 't' && String.unsafe_get s (pos+3) = 'u' && String.unsafe_get s (pos+4) = 'a' && String.unsafe_get s (pos+5) = 'l' && String.unsafe_get s (pos+6) = '_' && String.unsafe_get s (pos+7) = 'r' && String.unsafe_get s (pos+8) = 'e' && String.unsafe_get s (pos+9) = 'c' && String.unsafe_get s (pos+10) = 'u' && String.unsafe_get s (pos+11) = 'r' && String.unsafe_get s (pos+12) = 's' && String.unsafe_get s (pos+13) = 'e' && String.unsafe_get s (pos+14) = '2' then (
              0
            )
            else (
              -1
            )
        in
        let i = Yojson.Safe.map_ident p f lb in
        Atdgen_runtime.Oj_run.read_until_field_value p lb;
        (
          match i with
            | 0 ->
              field_mutual_recurse2 := (
                Some (
                  (
                    read_mutual_recurse2
                  ) p lb
                )
              );
            | _ -> (
                Yojson.Safe.skip_json p lb
              )
        );
      done;
      assert false;
    with Yojson.End_of_object -> (
        (
          {
            mutual_recurse2 = (match !field_mutual_recurse2 with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "mutual_recurse2");
          }
         : mutual_recurse1)
      )
)
and mutual_recurse1_of_string s =
  read_mutual_recurse1 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
and read_mutual_recurse2 = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    Yojson.Safe.read_lcurl p lb;
    let field_mutual_recurse1 = ref (None) in
    try
      Yojson.Safe.read_space p lb;
      Yojson.Safe.read_object_end lb;
      Yojson.Safe.read_space p lb;
      let f =
        fun s pos len ->
          if pos < 0 || len < 0 || pos + len > String.length s then
            invalid_arg "out-of-bounds substring position or length";
          if len = 15 && String.unsafe_get s pos = 'm' && String.unsafe_get s (pos+1) = 'u' && String.unsafe_get s (pos+2) = 't' && String.unsafe_get s (pos+3) = 'u' && String.unsafe_get s (pos+4) = 'a' && String.unsafe_get s (pos+5) = 'l' && String.unsafe_get s (pos+6) = '_' && String.unsafe_get s (pos+7) = 'r' && String.unsafe_get s (pos+8) = 'e' && String.unsafe_get s (pos+9) = 'c' && String.unsafe_get s (pos+10) = 'u' && String.unsafe_get s (pos+11) = 'r' && String.unsafe_get s (pos+12) = 's' && String.unsafe_get s (pos+13) = 'e' && String.unsafe_get s (pos+14) = '1' then (
            0
          )
          else (
            -1
          )
      in
      let i = Yojson.Safe.map_ident p f lb in
      Atdgen_runtime.Oj_run.read_until_field_value p lb;
      (
        match i with
          | 0 ->
            field_mutual_recurse1 := (
              Some (
                (
                  read_mutual_recurse1
                ) p lb
              )
            );
          | _ -> (
              Yojson.Safe.skip_json p lb
            )
      );
      while true do
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_object_sep p lb;
        Yojson.Safe.read_space p lb;
        let f =
          fun s pos len ->
            if pos < 0 || len < 0 || pos + len > String.length s then
              invalid_arg "out-of-bounds substring position or length";
            if len = 15 && String.unsafe_get s pos = 'm' && String.unsafe_get s (pos+1) = 'u' && String.unsafe_get s (pos+2) = 't' && String.unsafe_get s (pos+3) = 'u' && String.unsafe_get s (pos+4) = 'a' && String.unsafe_get s (pos+5) = 'l' && String.unsafe_get s (pos+6) = '_' && String.unsafe_get s (pos+7) = 'r' && String.unsafe_get s (pos+8) = 'e' && String.unsafe_get s (pos+9) = 'c' && String.unsafe_get s (pos+10) = 'u' && String.unsafe_get s (pos+11) = 'r' && String.unsafe_get s (pos+12) = 's' && String.unsafe_get s (pos+13) = 'e' && String.unsafe_get s (pos+14) = '1' then (
              0
            )
            else (
              -1
            )
        in
        let i = Yojson.Safe.map_ident p f lb in
        Atdgen_runtime.Oj_run.read_until_field_value p lb;
        (
          match i with
            | 0 ->
              field_mutual_recurse1 := (
                Some (
                  (
                    read_mutual_recurse1
                  ) p lb
                )
              );
            | _ -> (
                Yojson.Safe.skip_json p lb
              )
        );
      done;
      assert false;
    with Yojson.End_of_object -> (
        (
          {
            mutual_recurse1 = (match !field_mutual_recurse1 with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "mutual_recurse1");
          }
         : mutual_recurse2)
      )
)
and mutual_recurse2_of_string s =
  read_mutual_recurse2 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let rec write__5 ob x = (
  Atdgen_runtime.Oj_run.write_list (
    write_recurse
  )
) ob x
and string_of__5 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__5 ob x;
  Bi_outbuf.contents ob
and write_recurse : _ -> recurse -> _ = (
  fun ob (x : recurse) ->
    Bi_outbuf.add_char ob '{';
    let is_first = ref true in
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"recurse_items\":";
    (
      write__5
    )
      ob x.recurse_items;
    Bi_outbuf.add_char ob '}';
)
and string_of_recurse ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_recurse ob x;
  Bi_outbuf.contents ob
let rec read__5 p lb = (
  Atdgen_runtime.Oj_run.read_list (
    read_recurse
  )
) p lb
and _5_of_string s =
  read__5 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
and read_recurse = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    Yojson.Safe.read_lcurl p lb;
    let field_recurse_items = ref (None) in
    try
      Yojson.Safe.read_space p lb;
      Yojson.Safe.read_object_end lb;
      Yojson.Safe.read_space p lb;
      let f =
        fun s pos len ->
          if pos < 0 || len < 0 || pos + len > String.length s then
            invalid_arg "out-of-bounds substring position or length";
          if len = 13 && String.unsafe_get s pos = 'r' && String.unsafe_get s (pos+1) = 'e' && String.unsafe_get s (pos+2) = 'c' && String.unsafe_get s (pos+3) = 'u' && String.unsafe_get s (pos+4) = 'r' && String.unsafe_get s (pos+5) = 's' && String.unsafe_get s (pos+6) = 'e' && String.unsafe_get s (pos+7) = '_' && String.unsafe_get s (pos+8) = 'i' && String.unsafe_get s (pos+9) = 't' && String.unsafe_get s (pos+10) = 'e' && String.unsafe_get s (pos+11) = 'm' && String.unsafe_get s (pos+12) = 's' then (
            0
          )
          else (
            -1
          )
      in
      let i = Yojson.Safe.map_ident p f lb in
      Atdgen_runtime.Oj_run.read_until_field_value p lb;
      (
        match i with
          | 0 ->
            field_recurse_items := (
              Some (
                (
                  read__5
                ) p lb
              )
            );
          | _ -> (
              Yojson.Safe.skip_json p lb
            )
      );
      while true do
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_object_sep p lb;
        Yojson.Safe.read_space p lb;
        let f =
          fun s pos len ->
            if pos < 0 || len < 0 || pos + len > String.length s then
              invalid_arg "out-of-bounds substring position or length";
            if len = 13 && String.unsafe_get s pos = 'r' && String.unsafe_get s (pos+1) = 'e' && String.unsafe_get s (pos+2) = 'c' && String.unsafe_get s (pos+3) = 'u' && String.unsafe_get s (pos+4) = 'r' && String.unsafe_get s (pos+5) = 's' && String.unsafe_get s (pos+6) = 'e' && String.unsafe_get s (pos+7) = '_' && String.unsafe_get s (pos+8) = 'i' && String.unsafe_get s (pos+9) = 't' && String.unsafe_get s (pos+10) = 'e' && String.unsafe_get s (pos+11) = 'm' && String.unsafe_get s (pos+12) = 's' then (
              0
            )
            else (
              -1
            )
        in
        let i = Yojson.Safe.map_ident p f lb in
        Atdgen_runtime.Oj_run.read_until_field_value p lb;
        (
          match i with
            | 0 ->
              field_recurse_items := (
                Some (
                  (
                    read__5
                  ) p lb
                )
              );
            | _ -> (
                Yojson.Safe.skip_json p lb
              )
        );
      done;
      assert false;
    with Yojson.End_of_object -> (
        (
          {
            recurse_items = (match !field_recurse_items with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "recurse_items");
          }
         : recurse)
      )
)
and recurse_of_string s =
  read_recurse (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_valid = (
  Yojson.Safe.write_bool
)
let string_of_valid ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_valid ob x;
  Bi_outbuf.contents ob
let read_valid = (
  Atdgen_runtime.Oj_run.read_bool
)
let valid_of_string s =
  read_valid (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_v2 : _ -> v2 -> _ = (
  fun ob x ->
    match x with
      | V1_foo x ->
        Bi_outbuf.add_string ob "[\"V1_foo\",";
        (
          Yojson.Safe.write_int
        ) ob x;
        Bi_outbuf.add_char ob ']'
      | V2_bar x ->
        Bi_outbuf.add_string ob "[\"V2_bar\",";
        (
          Yojson.Safe.write_bool
        ) ob x;
        Bi_outbuf.add_char ob ']'
)
let string_of_v2 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_v2 ob x;
  Bi_outbuf.contents ob
let read_v2 = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    match Yojson.Safe.start_any_variant p lb with
      | `Edgy_bracket -> (
          match Yojson.Safe.read_ident p lb with
            | "V1_foo" ->
              Atdgen_runtime.Oj_run.read_until_field_value p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_int
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              (V1_foo x : v2)
            | "V2_bar" ->
              Atdgen_runtime.Oj_run.read_until_field_value p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_bool
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              (V2_bar x : v2)
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Double_quote -> (
          match Yojson.Safe.finish_string p lb with
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Square_bracket -> (
          match Atdgen_runtime.Oj_run.read_string p lb with
            | "V1_foo" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_comma p lb;
              Yojson.Safe.read_space p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_int
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_rbr p lb;
              (V1_foo x : v2)
            | "V2_bar" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_comma p lb;
              Yojson.Safe.read_space p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_bool
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_rbr p lb;
              (V2_bar x : v2)
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
)
let v2_of_string s =
  read_v2 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_v1 : _ -> v1 -> _ = (
  fun ob x ->
    match x with
      | V1_foo x ->
        Bi_outbuf.add_string ob "[\"V1_foo\",";
        (
          Yojson.Safe.write_bool
        ) ob x;
        Bi_outbuf.add_char ob ']'
      | V2_bar x ->
        Bi_outbuf.add_string ob "[\"V2_bar\",";
        (
          Yojson.Safe.write_int
        ) ob x;
        Bi_outbuf.add_char ob ']'
)
let string_of_v1 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_v1 ob x;
  Bi_outbuf.contents ob
let read_v1 = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    match Yojson.Safe.start_any_variant p lb with
      | `Edgy_bracket -> (
          match Yojson.Safe.read_ident p lb with
            | "V1_foo" ->
              Atdgen_runtime.Oj_run.read_until_field_value p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_bool
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              (V1_foo x : v1)
            | "V2_bar" ->
              Atdgen_runtime.Oj_run.read_until_field_value p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_int
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              (V2_bar x : v1)
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Double_quote -> (
          match Yojson.Safe.finish_string p lb with
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Square_bracket -> (
          match Atdgen_runtime.Oj_run.read_string p lb with
            | "V1_foo" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_comma p lb;
              Yojson.Safe.read_space p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_bool
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_rbr p lb;
              (V1_foo x : v1)
            | "V2_bar" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_comma p lb;
              Yojson.Safe.read_space p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_int
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_rbr p lb;
              (V2_bar x : v1)
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
)
let v1_of_string s =
  read_v1 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__6 = (
  Atdgen_runtime.Oj_run.write_assoc_list (
    Yojson.Safe.write_string
  ) (
    Yojson.Safe.write_int
  )
)
let string_of__6 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__6 ob x;
  Bi_outbuf.contents ob
let read__6 = (
  Atdgen_runtime.Oj_run.read_assoc_list (
    Atdgen_runtime.Oj_run.read_string
  ) (
    Atdgen_runtime.Oj_run.read_int
  )
)
let _6_of_string s =
  read__6 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_using_object : _ -> using_object -> _ = (
  fun ob (x : using_object) ->
    Bi_outbuf.add_char ob '{';
    let is_first = ref true in
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"f\":";
    (
      write__6
    )
      ob x.f;
    Bi_outbuf.add_char ob '}';
)
let string_of_using_object ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_using_object ob x;
  Bi_outbuf.contents ob
let read_using_object = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    Yojson.Safe.read_lcurl p lb;
    let field_f = ref (None) in
    try
      Yojson.Safe.read_space p lb;
      Yojson.Safe.read_object_end lb;
      Yojson.Safe.read_space p lb;
      let f =
        fun s pos len ->
          if pos < 0 || len < 0 || pos + len > String.length s then
            invalid_arg "out-of-bounds substring position or length";
          if len = 1 && String.unsafe_get s pos = 'f' then (
            0
          )
          else (
            -1
          )
      in
      let i = Yojson.Safe.map_ident p f lb in
      Atdgen_runtime.Oj_run.read_until_field_value p lb;
      (
        match i with
          | 0 ->
            field_f := (
              Some (
                (
                  read__6
                ) p lb
              )
            );
          | _ -> (
              Yojson.Safe.skip_json p lb
            )
      );
      while true do
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_object_sep p lb;
        Yojson.Safe.read_space p lb;
        let f =
          fun s pos len ->
            if pos < 0 || len < 0 || pos + len > String.length s then
              invalid_arg "out-of-bounds substring position or length";
            if len = 1 && String.unsafe_get s pos = 'f' then (
              0
            )
            else (
              -1
            )
        in
        let i = Yojson.Safe.map_ident p f lb in
        Atdgen_runtime.Oj_run.read_until_field_value p lb;
        (
          match i with
            | 0 ->
              field_f := (
                Some (
                  (
                    read__6
                  ) p lb
                )
              );
            | _ -> (
                Yojson.Safe.skip_json p lb
              )
        );
      done;
      assert false;
    with Yojson.End_of_object -> (
        (
          {
            f = (match !field_f with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "f");
          }
         : using_object)
      )
)
let using_object_of_string s =
  read_using_object (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_single_tuple = (
  fun ob x ->
    match x with
      | `Single_tuple x ->
        Bi_outbuf.add_string ob "[\"Single_tuple\",";
        (
          fun ob x ->
            Bi_outbuf.add_char ob '[';
            (let x = x in
            (
              Yojson.Safe.write_int
            ) ob x
            );
            Bi_outbuf.add_char ob ']';
        ) ob x;
        Bi_outbuf.add_char ob ']'
)
let string_of_single_tuple ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_single_tuple ob x;
  Bi_outbuf.contents ob
let read_single_tuple = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    match Yojson.Safe.start_any_variant p lb with
      | `Edgy_bracket -> (
          match Yojson.Safe.read_ident p lb with
            | "Single_tuple" ->
              Atdgen_runtime.Oj_run.read_until_field_value p lb;
              let x = (
                  fun p lb ->
                    Yojson.Safe.read_space p lb;
                    let std_tuple = Yojson.Safe.start_any_tuple p lb in
                    let len = ref 0 in
                    let end_of_tuple = ref false in
                    (try
                      let x0 =
                        let x =
                          (
                            Atdgen_runtime.Oj_run.read_int
                          ) p lb
                        in
                        incr len;
                        (try
                          Yojson.Safe.read_space p lb;
                          Yojson.Safe.read_tuple_sep2 p std_tuple lb;
                        with Yojson.End_of_tuple -> end_of_tuple := true);
                        x
                      in
                      if not !end_of_tuple then (
                        try
                          while true do
                            Yojson.Safe.skip_json p lb;
                            Yojson.Safe.read_space p lb;
                            Yojson.Safe.read_tuple_sep2 p std_tuple lb;
                          done
                        with Yojson.End_of_tuple -> ()
                      );
                      (x0)
                    with Yojson.End_of_tuple ->
                      Atdgen_runtime.Oj_run.missing_tuple_fields p !len [ 0 ]);
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              `Single_tuple x
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Double_quote -> (
          match Yojson.Safe.finish_string p lb with
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Square_bracket -> (
          match Atdgen_runtime.Oj_run.read_string p lb with
            | "Single_tuple" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_comma p lb;
              Yojson.Safe.read_space p lb;
              let x = (
                  fun p lb ->
                    Yojson.Safe.read_space p lb;
                    let std_tuple = Yojson.Safe.start_any_tuple p lb in
                    let len = ref 0 in
                    let end_of_tuple = ref false in
                    (try
                      let x0 =
                        let x =
                          (
                            Atdgen_runtime.Oj_run.read_int
                          ) p lb
                        in
                        incr len;
                        (try
                          Yojson.Safe.read_space p lb;
                          Yojson.Safe.read_tuple_sep2 p std_tuple lb;
                        with Yojson.End_of_tuple -> end_of_tuple := true);
                        x
                      in
                      if not !end_of_tuple then (
                        try
                          while true do
                            Yojson.Safe.skip_json p lb;
                            Yojson.Safe.read_space p lb;
                            Yojson.Safe.read_tuple_sep2 p std_tuple lb;
                          done
                        with Yojson.End_of_tuple -> ()
                      );
                      (x0)
                    with Yojson.End_of_tuple ->
                      Atdgen_runtime.Oj_run.missing_tuple_fields p !len [ 0 ]);
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_rbr p lb;
              `Single_tuple x
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
)
let single_tuple_of_string s =
  read_single_tuple (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__2 = (
  fun ob x -> (
    let x = ( function `Id s -> s ) x in (
      Yojson.Safe.write_string
    ) ob x)
)
let string_of__2 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__2 ob x;
  Bi_outbuf.contents ob
let read__2 = (
  fun p lb ->
    let x = (
      Atdgen_runtime.Oj_run.read_string
    ) p lb in
    ( fun s -> `Id s ) x
)
let _2_of_string s =
  read__2 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_id = (
  write__2
)
let string_of_id ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_id ob x;
  Bi_outbuf.contents ob
let read_id = (
  read__2
)
let id_of_string s =
  read_id (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__3 = (
  fun ob x ->
    match x with
      | `Foo x ->
        Bi_outbuf.add_string ob "[\"Foo\",";
        (
          fun ob x ->
            Bi_outbuf.add_char ob '[';
            (let x, _ = x in
            (
              Yojson.Safe.write_int
            ) ob x
            );
            Bi_outbuf.add_char ob ',';
            (let _, x = x in
            (
              Yojson.Safe.write_int
            ) ob x
            );
            Bi_outbuf.add_char ob ']';
        ) ob x;
        Bi_outbuf.add_char ob ']'
      | `Bar -> Bi_outbuf.add_string ob "\"Bar\""
      | `Foobar x ->
        Bi_outbuf.add_string ob "[\"Foobar\",";
        (
          Yojson.Safe.write_null
        ) ob x;
        Bi_outbuf.add_char ob ']'
      | `Foo_id x ->
        Bi_outbuf.add_string ob "[\"Foo_id\",";
        (
          write_id
        ) ob x;
        Bi_outbuf.add_char ob ']'
)
let string_of__3 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__3 ob x;
  Bi_outbuf.contents ob
let read__3 = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    match Yojson.Safe.start_any_variant p lb with
      | `Edgy_bracket -> (
          match Yojson.Safe.read_ident p lb with
            | "Foo" ->
              Atdgen_runtime.Oj_run.read_until_field_value p lb;
              let x = (
                  fun p lb ->
                    Yojson.Safe.read_space p lb;
                    let std_tuple = Yojson.Safe.start_any_tuple p lb in
                    let len = ref 0 in
                    let end_of_tuple = ref false in
                    (try
                      let x0 =
                        let x =
                          (
                            Atdgen_runtime.Oj_run.read_int
                          ) p lb
                        in
                        incr len;
                        Yojson.Safe.read_space p lb;
                        Yojson.Safe.read_tuple_sep2 p std_tuple lb;
                        x
                      in
                      let x1 =
                        let x =
                          (
                            Atdgen_runtime.Oj_run.read_int
                          ) p lb
                        in
                        incr len;
                        (try
                          Yojson.Safe.read_space p lb;
                          Yojson.Safe.read_tuple_sep2 p std_tuple lb;
                        with Yojson.End_of_tuple -> end_of_tuple := true);
                        x
                      in
                      if not !end_of_tuple then (
                        try
                          while true do
                            Yojson.Safe.skip_json p lb;
                            Yojson.Safe.read_space p lb;
                            Yojson.Safe.read_tuple_sep2 p std_tuple lb;
                          done
                        with Yojson.End_of_tuple -> ()
                      );
                      (x0, x1)
                    with Yojson.End_of_tuple ->
                      Atdgen_runtime.Oj_run.missing_tuple_fields p !len [ 0; 1 ]);
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              `Foo x
            | "Bar" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              `Bar
            | "Foobar" ->
              Atdgen_runtime.Oj_run.read_until_field_value p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_null
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              `Foobar x
            | "Foo_id" ->
              Atdgen_runtime.Oj_run.read_until_field_value p lb;
              let x = (
                  read_id
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              `Foo_id x
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Double_quote -> (
          match Yojson.Safe.finish_string p lb with
            | "Bar" ->
              `Bar
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Square_bracket -> (
          match Atdgen_runtime.Oj_run.read_string p lb with
            | "Foo" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_comma p lb;
              Yojson.Safe.read_space p lb;
              let x = (
                  fun p lb ->
                    Yojson.Safe.read_space p lb;
                    let std_tuple = Yojson.Safe.start_any_tuple p lb in
                    let len = ref 0 in
                    let end_of_tuple = ref false in
                    (try
                      let x0 =
                        let x =
                          (
                            Atdgen_runtime.Oj_run.read_int
                          ) p lb
                        in
                        incr len;
                        Yojson.Safe.read_space p lb;
                        Yojson.Safe.read_tuple_sep2 p std_tuple lb;
                        x
                      in
                      let x1 =
                        let x =
                          (
                            Atdgen_runtime.Oj_run.read_int
                          ) p lb
                        in
                        incr len;
                        (try
                          Yojson.Safe.read_space p lb;
                          Yojson.Safe.read_tuple_sep2 p std_tuple lb;
                        with Yojson.End_of_tuple -> end_of_tuple := true);
                        x
                      in
                      if not !end_of_tuple then (
                        try
                          while true do
                            Yojson.Safe.skip_json p lb;
                            Yojson.Safe.read_space p lb;
                            Yojson.Safe.read_tuple_sep2 p std_tuple lb;
                          done
                        with Yojson.End_of_tuple -> ()
                      );
                      (x0, x1)
                    with Yojson.End_of_tuple ->
                      Atdgen_runtime.Oj_run.missing_tuple_fields p !len [ 0; 1 ]);
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_rbr p lb;
              `Foo x
            | "Foobar" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_comma p lb;
              Yojson.Safe.read_space p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_null
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_rbr p lb;
              `Foobar x
            | "Foo_id" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_comma p lb;
              Yojson.Safe.read_space p lb;
              let x = (
                  read_id
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_rbr p lb;
              `Foo_id x
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
)
let _3_of_string s =
  read__3 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__4 = (
  Atdgen_runtime.Oj_run.write_list (
    write__3
  )
)
let string_of__4 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__4 ob x;
  Bi_outbuf.contents ob
let read__4 = (
  Atdgen_runtime.Oj_run.read_list (
    read__3
  )
)
let _4_of_string s =
  read__4 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_simple_vars = (
  write__4
)
let string_of_simple_vars ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_simple_vars ob x;
  Bi_outbuf.contents ob
let read_simple_vars = (
  read__4
)
let simple_vars_of_string s =
  read_simple_vars (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_simple_var write__a = (
  fun ob x ->
    match x with
      | `Foo x ->
        Bi_outbuf.add_string ob "[\"Foo\",";
        (
          fun ob x ->
            Bi_outbuf.add_char ob '[';
            (let x, _ = x in
            (
              Yojson.Safe.write_int
            ) ob x
            );
            Bi_outbuf.add_char ob ',';
            (let _, x = x in
            (
              Yojson.Safe.write_int
            ) ob x
            );
            Bi_outbuf.add_char ob ']';
        ) ob x;
        Bi_outbuf.add_char ob ']'
      | `Bar -> Bi_outbuf.add_string ob "\"Bar\""
      | `Foobar x ->
        Bi_outbuf.add_string ob "[\"Foobar\",";
        (
          write__a
        ) ob x;
        Bi_outbuf.add_char ob ']'
      | `Foo_id x ->
        Bi_outbuf.add_string ob "[\"Foo_id\",";
        (
          write_id
        ) ob x;
        Bi_outbuf.add_char ob ']'
)
let string_of_simple_var write__a ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_simple_var write__a ob x;
  Bi_outbuf.contents ob
let read_simple_var read__a = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    match Yojson.Safe.start_any_variant p lb with
      | `Edgy_bracket -> (
          match Yojson.Safe.read_ident p lb with
            | "Foo" ->
              Atdgen_runtime.Oj_run.read_until_field_value p lb;
              let x = (
                  fun p lb ->
                    Yojson.Safe.read_space p lb;
                    let std_tuple = Yojson.Safe.start_any_tuple p lb in
                    let len = ref 0 in
                    let end_of_tuple = ref false in
                    (try
                      let x0 =
                        let x =
                          (
                            Atdgen_runtime.Oj_run.read_int
                          ) p lb
                        in
                        incr len;
                        Yojson.Safe.read_space p lb;
                        Yojson.Safe.read_tuple_sep2 p std_tuple lb;
                        x
                      in
                      let x1 =
                        let x =
                          (
                            Atdgen_runtime.Oj_run.read_int
                          ) p lb
                        in
                        incr len;
                        (try
                          Yojson.Safe.read_space p lb;
                          Yojson.Safe.read_tuple_sep2 p std_tuple lb;
                        with Yojson.End_of_tuple -> end_of_tuple := true);
                        x
                      in
                      if not !end_of_tuple then (
                        try
                          while true do
                            Yojson.Safe.skip_json p lb;
                            Yojson.Safe.read_space p lb;
                            Yojson.Safe.read_tuple_sep2 p std_tuple lb;
                          done
                        with Yojson.End_of_tuple -> ()
                      );
                      (x0, x1)
                    with Yojson.End_of_tuple ->
                      Atdgen_runtime.Oj_run.missing_tuple_fields p !len [ 0; 1 ]);
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              `Foo x
            | "Bar" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              `Bar
            | "Foobar" ->
              Atdgen_runtime.Oj_run.read_until_field_value p lb;
              let x = (
                  read__a
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              `Foobar x
            | "Foo_id" ->
              Atdgen_runtime.Oj_run.read_until_field_value p lb;
              let x = (
                  read_id
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              `Foo_id x
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Double_quote -> (
          match Yojson.Safe.finish_string p lb with
            | "Bar" ->
              `Bar
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Square_bracket -> (
          match Atdgen_runtime.Oj_run.read_string p lb with
            | "Foo" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_comma p lb;
              Yojson.Safe.read_space p lb;
              let x = (
                  fun p lb ->
                    Yojson.Safe.read_space p lb;
                    let std_tuple = Yojson.Safe.start_any_tuple p lb in
                    let len = ref 0 in
                    let end_of_tuple = ref false in
                    (try
                      let x0 =
                        let x =
                          (
                            Atdgen_runtime.Oj_run.read_int
                          ) p lb
                        in
                        incr len;
                        Yojson.Safe.read_space p lb;
                        Yojson.Safe.read_tuple_sep2 p std_tuple lb;
                        x
                      in
                      let x1 =
                        let x =
                          (
                            Atdgen_runtime.Oj_run.read_int
                          ) p lb
                        in
                        incr len;
                        (try
                          Yojson.Safe.read_space p lb;
                          Yojson.Safe.read_tuple_sep2 p std_tuple lb;
                        with Yojson.End_of_tuple -> end_of_tuple := true);
                        x
                      in
                      if not !end_of_tuple then (
                        try
                          while true do
                            Yojson.Safe.skip_json p lb;
                            Yojson.Safe.read_space p lb;
                            Yojson.Safe.read_tuple_sep2 p std_tuple lb;
                          done
                        with Yojson.End_of_tuple -> ()
                      );
                      (x0, x1)
                    with Yojson.End_of_tuple ->
                      Atdgen_runtime.Oj_run.missing_tuple_fields p !len [ 0; 1 ]);
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_rbr p lb;
              `Foo x
            | "Foobar" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_comma p lb;
              Yojson.Safe.read_space p lb;
              let x = (
                  read__a
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_rbr p lb;
              `Foobar x
            | "Foo_id" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_comma p lb;
              Yojson.Safe.read_space p lb;
              let x = (
                  read_id
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_rbr p lb;
              `Foo_id x
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
)
let simple_var_of_string read__a s =
  read_simple_var read__a (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_same_pair write__a = (
  fun ob x ->
    Bi_outbuf.add_char ob '[';
    (let x, _ = x in
    (
      write__a
    ) ob x
    );
    Bi_outbuf.add_char ob ',';
    (let _, x = x in
    (
      write__a
    ) ob x
    );
    Bi_outbuf.add_char ob ']';
)
let string_of_same_pair write__a ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_same_pair write__a ob x;
  Bi_outbuf.contents ob
let read_same_pair read__a = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    let std_tuple = Yojson.Safe.start_any_tuple p lb in
    let len = ref 0 in
    let end_of_tuple = ref false in
    (try
      let x0 =
        let x =
          (
            read__a
          ) p lb
        in
        incr len;
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_tuple_sep2 p std_tuple lb;
        x
      in
      let x1 =
        let x =
          (
            read__a
          ) p lb
        in
        incr len;
        (try
          Yojson.Safe.read_space p lb;
          Yojson.Safe.read_tuple_sep2 p std_tuple lb;
        with Yojson.End_of_tuple -> end_of_tuple := true);
        x
      in
      if not !end_of_tuple then (
        try
          while true do
            Yojson.Safe.skip_json p lb;
            Yojson.Safe.read_space p lb;
            Yojson.Safe.read_tuple_sep2 p std_tuple lb;
          done
        with Yojson.End_of_tuple -> ()
      );
      (x0, x1)
    with Yojson.End_of_tuple ->
      Atdgen_runtime.Oj_run.missing_tuple_fields p !len [ 0; 1 ]);
)
let same_pair_of_string read__a s =
  read_same_pair read__a (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_record_json_name : _ -> record_json_name -> _ = (
  fun ob (x : record_json_name) ->
    Bi_outbuf.add_char ob '{';
    let is_first = ref true in
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"bar\":";
    (
      Yojson.Safe.write_int
    )
      ob x.foo;
    Bi_outbuf.add_char ob '}';
)
let string_of_record_json_name ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_record_json_name ob x;
  Bi_outbuf.contents ob
let read_record_json_name = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    Yojson.Safe.read_lcurl p lb;
    let field_foo = ref (None) in
    try
      Yojson.Safe.read_space p lb;
      Yojson.Safe.read_object_end lb;
      Yojson.Safe.read_space p lb;
      let f =
        fun s pos len ->
          if pos < 0 || len < 0 || pos + len > String.length s then
            invalid_arg "out-of-bounds substring position or length";
          if len = 3 && String.unsafe_get s pos = 'b' && String.unsafe_get s (pos+1) = 'a' && String.unsafe_get s (pos+2) = 'r' then (
            0
          )
          else (
            -1
          )
      in
      let i = Yojson.Safe.map_ident p f lb in
      Atdgen_runtime.Oj_run.read_until_field_value p lb;
      (
        match i with
          | 0 ->
            field_foo := (
              Some (
                (
                  Atdgen_runtime.Oj_run.read_int
                ) p lb
              )
            );
          | _ -> (
              Yojson.Safe.skip_json p lb
            )
      );
      while true do
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_object_sep p lb;
        Yojson.Safe.read_space p lb;
        let f =
          fun s pos len ->
            if pos < 0 || len < 0 || pos + len > String.length s then
              invalid_arg "out-of-bounds substring position or length";
            if len = 3 && String.unsafe_get s pos = 'b' && String.unsafe_get s (pos+1) = 'a' && String.unsafe_get s (pos+2) = 'r' then (
              0
            )
            else (
              -1
            )
        in
        let i = Yojson.Safe.map_ident p f lb in
        Atdgen_runtime.Oj_run.read_until_field_value p lb;
        (
          match i with
            | 0 ->
              field_foo := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_int
                  ) p lb
                )
              );
            | _ -> (
                Yojson.Safe.skip_json p lb
              )
        );
      done;
      assert false;
    with Yojson.End_of_object -> (
        (
          {
            foo = (match !field_foo with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "foo");
          }
         : record_json_name)
      )
)
let record_json_name_of_string s =
  read_record_json_name (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_point = (
  fun ob x ->
    Bi_outbuf.add_char ob '[';
    (let x, _, _, _ = x in
    (
      Yojson.Safe.write_int
    ) ob x
    );
    Bi_outbuf.add_char ob ',';
    (let _, x, _, _ = x in
    (
      Yojson.Safe.write_int
    ) ob x
    );
    Bi_outbuf.add_char ob ',';
    (let _, _, x, _ = x in
    (
      Yojson.Safe.write_string
    ) ob x
    );
    Bi_outbuf.add_char ob ',';
    (let _, _, _, x = x in
    (
      Yojson.Safe.write_null
    ) ob x
    );
    Bi_outbuf.add_char ob ']';
)
let string_of_point ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_point ob x;
  Bi_outbuf.contents ob
let read_point = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    let std_tuple = Yojson.Safe.start_any_tuple p lb in
    let len = ref 0 in
    let end_of_tuple = ref false in
    (try
      let x0 =
        let x =
          (
            Atdgen_runtime.Oj_run.read_int
          ) p lb
        in
        incr len;
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_tuple_sep2 p std_tuple lb;
        x
      in
      let x1 =
        let x =
          (
            Atdgen_runtime.Oj_run.read_int
          ) p lb
        in
        incr len;
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_tuple_sep2 p std_tuple lb;
        x
      in
      let x2 =
        let x =
          (
            Atdgen_runtime.Oj_run.read_string
          ) p lb
        in
        incr len;
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_tuple_sep2 p std_tuple lb;
        x
      in
      let x3 =
        let x =
          (
            Atdgen_runtime.Oj_run.read_null
          ) p lb
        in
        incr len;
        (try
          Yojson.Safe.read_space p lb;
          Yojson.Safe.read_tuple_sep2 p std_tuple lb;
        with Yojson.End_of_tuple -> end_of_tuple := true);
        x
      in
      if not !end_of_tuple then (
        try
          while true do
            Yojson.Safe.skip_json p lb;
            Yojson.Safe.read_space p lb;
            Yojson.Safe.read_tuple_sep2 p std_tuple lb;
          done
        with Yojson.End_of_tuple -> ()
      );
      (x0, x1, x2, x3)
    with Yojson.End_of_tuple ->
      Atdgen_runtime.Oj_run.missing_tuple_fields p !len [ 0; 1; 2; 3 ]);
)
let point_of_string s =
  read_point (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_param_similar write__a : _ -> 'a param_similar -> _ = (
  fun ob (x : 'a param_similar) ->
    Bi_outbuf.add_char ob '{';
    let is_first = ref true in
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"data\":";
    (
      write__a
    )
      ob x.data;
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"something\":";
    (
      Yojson.Safe.write_int
    )
      ob x.something;
    Bi_outbuf.add_char ob '}';
)
let string_of_param_similar write__a ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_param_similar write__a ob x;
  Bi_outbuf.contents ob
let read_param_similar read__a = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    Yojson.Safe.read_lcurl p lb;
    let field_data = ref (None) in
    let field_something = ref (None) in
    try
      Yojson.Safe.read_space p lb;
      Yojson.Safe.read_object_end lb;
      Yojson.Safe.read_space p lb;
      let f =
        fun s pos len ->
          if pos < 0 || len < 0 || pos + len > String.length s then
            invalid_arg "out-of-bounds substring position or length";
          match len with
            | 4 -> (
                if String.unsafe_get s pos = 'd' && String.unsafe_get s (pos+1) = 'a' && String.unsafe_get s (pos+2) = 't' && String.unsafe_get s (pos+3) = 'a' then (
                  0
                )
                else (
                  -1
                )
              )
            | 9 -> (
                if String.unsafe_get s pos = 's' && String.unsafe_get s (pos+1) = 'o' && String.unsafe_get s (pos+2) = 'm' && String.unsafe_get s (pos+3) = 'e' && String.unsafe_get s (pos+4) = 't' && String.unsafe_get s (pos+5) = 'h' && String.unsafe_get s (pos+6) = 'i' && String.unsafe_get s (pos+7) = 'n' && String.unsafe_get s (pos+8) = 'g' then (
                  1
                )
                else (
                  -1
                )
              )
            | _ -> (
                -1
              )
      in
      let i = Yojson.Safe.map_ident p f lb in
      Atdgen_runtime.Oj_run.read_until_field_value p lb;
      (
        match i with
          | 0 ->
            field_data := (
              Some (
                (
                  read__a
                ) p lb
              )
            );
          | 1 ->
            field_something := (
              Some (
                (
                  Atdgen_runtime.Oj_run.read_int
                ) p lb
              )
            );
          | _ -> (
              Yojson.Safe.skip_json p lb
            )
      );
      while true do
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_object_sep p lb;
        Yojson.Safe.read_space p lb;
        let f =
          fun s pos len ->
            if pos < 0 || len < 0 || pos + len > String.length s then
              invalid_arg "out-of-bounds substring position or length";
            match len with
              | 4 -> (
                  if String.unsafe_get s pos = 'd' && String.unsafe_get s (pos+1) = 'a' && String.unsafe_get s (pos+2) = 't' && String.unsafe_get s (pos+3) = 'a' then (
                    0
                  )
                  else (
                    -1
                  )
                )
              | 9 -> (
                  if String.unsafe_get s pos = 's' && String.unsafe_get s (pos+1) = 'o' && String.unsafe_get s (pos+2) = 'm' && String.unsafe_get s (pos+3) = 'e' && String.unsafe_get s (pos+4) = 't' && String.unsafe_get s (pos+5) = 'h' && String.unsafe_get s (pos+6) = 'i' && String.unsafe_get s (pos+7) = 'n' && String.unsafe_get s (pos+8) = 'g' then (
                    1
                  )
                  else (
                    -1
                  )
                )
              | _ -> (
                  -1
                )
        in
        let i = Yojson.Safe.map_ident p f lb in
        Atdgen_runtime.Oj_run.read_until_field_value p lb;
        (
          match i with
            | 0 ->
              field_data := (
                Some (
                  (
                    read__a
                  ) p lb
                )
              );
            | 1 ->
              field_something := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_int
                  ) p lb
                )
              );
            | _ -> (
                Yojson.Safe.skip_json p lb
              )
        );
      done;
      assert false;
    with Yojson.End_of_object -> (
        (
          {
            data = (match !field_data with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "data");
            something = (match !field_something with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "something");
          }
         : 'a param_similar)
      )
)
let param_similar_of_string read__a s =
  read_param_similar read__a (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_param write__a : _ -> 'a param -> _ = (
  fun ob (x : 'a param) ->
    Bi_outbuf.add_char ob '{';
    let is_first = ref true in
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"data\":";
    (
      write__a
    )
      ob x.data;
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"nothing\":";
    (
      Yojson.Safe.write_null
    )
      ob x.nothing;
    Bi_outbuf.add_char ob '}';
)
let string_of_param write__a ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_param write__a ob x;
  Bi_outbuf.contents ob
let read_param read__a = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    Yojson.Safe.read_lcurl p lb;
    let field_data = ref (None) in
    let field_nothing = ref (None) in
    try
      Yojson.Safe.read_space p lb;
      Yojson.Safe.read_object_end lb;
      Yojson.Safe.read_space p lb;
      let f =
        fun s pos len ->
          if pos < 0 || len < 0 || pos + len > String.length s then
            invalid_arg "out-of-bounds substring position or length";
          match len with
            | 4 -> (
                if String.unsafe_get s pos = 'd' && String.unsafe_get s (pos+1) = 'a' && String.unsafe_get s (pos+2) = 't' && String.unsafe_get s (pos+3) = 'a' then (
                  0
                )
                else (
                  -1
                )
              )
            | 7 -> (
                if String.unsafe_get s pos = 'n' && String.unsafe_get s (pos+1) = 'o' && String.unsafe_get s (pos+2) = 't' && String.unsafe_get s (pos+3) = 'h' && String.unsafe_get s (pos+4) = 'i' && String.unsafe_get s (pos+5) = 'n' && String.unsafe_get s (pos+6) = 'g' then (
                  1
                )
                else (
                  -1
                )
              )
            | _ -> (
                -1
              )
      in
      let i = Yojson.Safe.map_ident p f lb in
      Atdgen_runtime.Oj_run.read_until_field_value p lb;
      (
        match i with
          | 0 ->
            field_data := (
              Some (
                (
                  read__a
                ) p lb
              )
            );
          | 1 ->
            field_nothing := (
              Some (
                (
                  Atdgen_runtime.Oj_run.read_null
                ) p lb
              )
            );
          | _ -> (
              Yojson.Safe.skip_json p lb
            )
      );
      while true do
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_object_sep p lb;
        Yojson.Safe.read_space p lb;
        let f =
          fun s pos len ->
            if pos < 0 || len < 0 || pos + len > String.length s then
              invalid_arg "out-of-bounds substring position or length";
            match len with
              | 4 -> (
                  if String.unsafe_get s pos = 'd' && String.unsafe_get s (pos+1) = 'a' && String.unsafe_get s (pos+2) = 't' && String.unsafe_get s (pos+3) = 'a' then (
                    0
                  )
                  else (
                    -1
                  )
                )
              | 7 -> (
                  if String.unsafe_get s pos = 'n' && String.unsafe_get s (pos+1) = 'o' && String.unsafe_get s (pos+2) = 't' && String.unsafe_get s (pos+3) = 'h' && String.unsafe_get s (pos+4) = 'i' && String.unsafe_get s (pos+5) = 'n' && String.unsafe_get s (pos+6) = 'g' then (
                    1
                  )
                  else (
                    -1
                  )
                )
              | _ -> (
                  -1
                )
        in
        let i = Yojson.Safe.map_ident p f lb in
        Atdgen_runtime.Oj_run.read_until_field_value p lb;
        (
          match i with
            | 0 ->
              field_data := (
                Some (
                  (
                    read__a
                  ) p lb
                )
              );
            | 1 ->
              field_nothing := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_null
                  ) p lb
                )
              );
            | _ -> (
                Yojson.Safe.skip_json p lb
              )
        );
      done;
      assert false;
    with Yojson.End_of_object -> (
        (
          {
            data = (match !field_data with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "data");
            nothing = (match !field_nothing with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "nothing");
          }
         : 'a param)
      )
)
let param_of_string read__a s =
  read_param read__a (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_pair write__a write__b : _ -> ('a, 'b) pair -> _ = (
  fun ob (x : ('a, 'b) pair) ->
    Bi_outbuf.add_char ob '{';
    let is_first = ref true in
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"left\":";
    (
      write__a
    )
      ob x.left;
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"right\":";
    (
      write__b
    )
      ob x.right;
    Bi_outbuf.add_char ob '}';
)
let string_of_pair write__a write__b ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_pair write__a write__b ob x;
  Bi_outbuf.contents ob
let read_pair read__a read__b = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    Yojson.Safe.read_lcurl p lb;
    let field_left = ref (None) in
    let field_right = ref (None) in
    try
      Yojson.Safe.read_space p lb;
      Yojson.Safe.read_object_end lb;
      Yojson.Safe.read_space p lb;
      let f =
        fun s pos len ->
          if pos < 0 || len < 0 || pos + len > String.length s then
            invalid_arg "out-of-bounds substring position or length";
          match len with
            | 4 -> (
                if String.unsafe_get s pos = 'l' && String.unsafe_get s (pos+1) = 'e' && String.unsafe_get s (pos+2) = 'f' && String.unsafe_get s (pos+3) = 't' then (
                  0
                )
                else (
                  -1
                )
              )
            | 5 -> (
                if String.unsafe_get s pos = 'r' && String.unsafe_get s (pos+1) = 'i' && String.unsafe_get s (pos+2) = 'g' && String.unsafe_get s (pos+3) = 'h' && String.unsafe_get s (pos+4) = 't' then (
                  1
                )
                else (
                  -1
                )
              )
            | _ -> (
                -1
              )
      in
      let i = Yojson.Safe.map_ident p f lb in
      Atdgen_runtime.Oj_run.read_until_field_value p lb;
      (
        match i with
          | 0 ->
            field_left := (
              Some (
                (
                  read__a
                ) p lb
              )
            );
          | 1 ->
            field_right := (
              Some (
                (
                  read__b
                ) p lb
              )
            );
          | _ -> (
              Yojson.Safe.skip_json p lb
            )
      );
      while true do
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_object_sep p lb;
        Yojson.Safe.read_space p lb;
        let f =
          fun s pos len ->
            if pos < 0 || len < 0 || pos + len > String.length s then
              invalid_arg "out-of-bounds substring position or length";
            match len with
              | 4 -> (
                  if String.unsafe_get s pos = 'l' && String.unsafe_get s (pos+1) = 'e' && String.unsafe_get s (pos+2) = 'f' && String.unsafe_get s (pos+3) = 't' then (
                    0
                  )
                  else (
                    -1
                  )
                )
              | 5 -> (
                  if String.unsafe_get s pos = 'r' && String.unsafe_get s (pos+1) = 'i' && String.unsafe_get s (pos+2) = 'g' && String.unsafe_get s (pos+3) = 'h' && String.unsafe_get s (pos+4) = 't' then (
                    1
                  )
                  else (
                    -1
                  )
                )
              | _ -> (
                  -1
                )
        in
        let i = Yojson.Safe.map_ident p f lb in
        Atdgen_runtime.Oj_run.read_until_field_value p lb;
        (
          match i with
            | 0 ->
              field_left := (
                Some (
                  (
                    read__a
                  ) p lb
                )
              );
            | 1 ->
              field_right := (
                Some (
                  (
                    read__b
                  ) p lb
                )
              );
            | _ -> (
                Yojson.Safe.skip_json p lb
              )
        );
      done;
      assert false;
    with Yojson.End_of_object -> (
        (
          {
            left = (match !field_left with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "left");
            right = (match !field_right with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "right");
          }
         : ('a, 'b) pair)
      )
)
let pair_of_string read__a read__b s =
  read_pair read__a read__b (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__1 write__a write__b = (
  Atdgen_runtime.Oj_run.write_list (
    write_pair write__a write__a
  )
)
let string_of__1 write__a write__b ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__1 write__a write__b ob x;
  Bi_outbuf.contents ob
let read__1 read__a read__b = (
  Atdgen_runtime.Oj_run.read_list (
    read_pair read__a read__a
  )
)
let _1_of_string read__a read__b s =
  read__1 read__a read__b (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_pairs write__a = (
  write__1 write__a write__a
)
let string_of_pairs write__a ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_pairs write__a ob x;
  Bi_outbuf.contents ob
let read_pairs read__a = (
  read__1 read__a read__a
)
let pairs_of_string read__a s =
  read_pairs read__a (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_label = (
  Yojson.Safe.write_string
)
let string_of_label ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_label ob x;
  Bi_outbuf.contents ob
let read_label = (
  Atdgen_runtime.Oj_run.read_string
)
let label_of_string s =
  read_label (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_labeled : _ -> labeled -> _ = (
  fun ob (x : labeled) ->
    Bi_outbuf.add_char ob '{';
    let is_first = ref true in
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"flag\":";
    (
      write_valid
    )
      ob x.flag;
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"lb\":";
    (
      write_label
    )
      ob x.lb;
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"count\":";
    (
      Yojson.Safe.write_int
    )
      ob x.count;
    Bi_outbuf.add_char ob '}';
)
let string_of_labeled ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_labeled ob x;
  Bi_outbuf.contents ob
let read_labeled = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    Yojson.Safe.read_lcurl p lb;
    let field_flag = ref (None) in
    let field_lb = ref (None) in
    let field_count = ref (None) in
    try
      Yojson.Safe.read_space p lb;
      Yojson.Safe.read_object_end lb;
      Yojson.Safe.read_space p lb;
      let f =
        fun s pos len ->
          if pos < 0 || len < 0 || pos + len > String.length s then
            invalid_arg "out-of-bounds substring position or length";
          match len with
            | 2 -> (
                if String.unsafe_get s pos = 'l' && String.unsafe_get s (pos+1) = 'b' then (
                  1
                )
                else (
                  -1
                )
              )
            | 4 -> (
                if String.unsafe_get s pos = 'f' && String.unsafe_get s (pos+1) = 'l' && String.unsafe_get s (pos+2) = 'a' && String.unsafe_get s (pos+3) = 'g' then (
                  0
                )
                else (
                  -1
                )
              )
            | 5 -> (
                if String.unsafe_get s pos = 'c' && String.unsafe_get s (pos+1) = 'o' && String.unsafe_get s (pos+2) = 'u' && String.unsafe_get s (pos+3) = 'n' && String.unsafe_get s (pos+4) = 't' then (
                  2
                )
                else (
                  -1
                )
              )
            | _ -> (
                -1
              )
      in
      let i = Yojson.Safe.map_ident p f lb in
      Atdgen_runtime.Oj_run.read_until_field_value p lb;
      (
        match i with
          | 0 ->
            field_flag := (
              Some (
                (
                  read_valid
                ) p lb
              )
            );
          | 1 ->
            field_lb := (
              Some (
                (
                  read_label
                ) p lb
              )
            );
          | 2 ->
            field_count := (
              Some (
                (
                  Atdgen_runtime.Oj_run.read_int
                ) p lb
              )
            );
          | _ -> (
              Yojson.Safe.skip_json p lb
            )
      );
      while true do
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_object_sep p lb;
        Yojson.Safe.read_space p lb;
        let f =
          fun s pos len ->
            if pos < 0 || len < 0 || pos + len > String.length s then
              invalid_arg "out-of-bounds substring position or length";
            match len with
              | 2 -> (
                  if String.unsafe_get s pos = 'l' && String.unsafe_get s (pos+1) = 'b' then (
                    1
                  )
                  else (
                    -1
                  )
                )
              | 4 -> (
                  if String.unsafe_get s pos = 'f' && String.unsafe_get s (pos+1) = 'l' && String.unsafe_get s (pos+2) = 'a' && String.unsafe_get s (pos+3) = 'g' then (
                    0
                  )
                  else (
                    -1
                  )
                )
              | 5 -> (
                  if String.unsafe_get s pos = 'c' && String.unsafe_get s (pos+1) = 'o' && String.unsafe_get s (pos+2) = 'u' && String.unsafe_get s (pos+3) = 'n' && String.unsafe_get s (pos+4) = 't' then (
                    2
                  )
                  else (
                    -1
                  )
                )
              | _ -> (
                  -1
                )
        in
        let i = Yojson.Safe.map_ident p f lb in
        Atdgen_runtime.Oj_run.read_until_field_value p lb;
        (
          match i with
            | 0 ->
              field_flag := (
                Some (
                  (
                    read_valid
                  ) p lb
                )
              );
            | 1 ->
              field_lb := (
                Some (
                  (
                    read_label
                  ) p lb
                )
              );
            | 2 ->
              field_count := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_int
                  ) p lb
                )
              );
            | _ -> (
                Yojson.Safe.skip_json p lb
              )
        );
      done;
      assert false;
    with Yojson.End_of_object -> (
        (
          {
            flag = (match !field_flag with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "flag");
            lb = (match !field_lb with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "lb");
            count = (match !field_count with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "count");
          }
         : labeled)
      )
)
let labeled_of_string s =
  read_labeled (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_from_module_a = (
  A_j.write_from_module_a
)
let string_of_from_module_a ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_from_module_a ob x;
  Bi_outbuf.contents ob
let read_from_module_a = (
  A_j.read_from_module_a
)
let from_module_a_of_string s =
  read_from_module_a (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_b : _ -> b -> _ = (
  fun ob (x : b) ->
    Bi_outbuf.add_char ob '{';
    let is_first = ref true in
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"thing\":";
    (
      Yojson.Safe.write_int
    )
      ob x.thing;
    Bi_outbuf.add_char ob '}';
)
let string_of_b ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_b ob x;
  Bi_outbuf.contents ob
let read_b = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    Yojson.Safe.read_lcurl p lb;
    let field_thing = ref (None) in
    try
      Yojson.Safe.read_space p lb;
      Yojson.Safe.read_object_end lb;
      Yojson.Safe.read_space p lb;
      let f =
        fun s pos len ->
          if pos < 0 || len < 0 || pos + len > String.length s then
            invalid_arg "out-of-bounds substring position or length";
          if len = 5 && String.unsafe_get s pos = 't' && String.unsafe_get s (pos+1) = 'h' && String.unsafe_get s (pos+2) = 'i' && String.unsafe_get s (pos+3) = 'n' && String.unsafe_get s (pos+4) = 'g' then (
            0
          )
          else (
            -1
          )
      in
      let i = Yojson.Safe.map_ident p f lb in
      Atdgen_runtime.Oj_run.read_until_field_value p lb;
      (
        match i with
          | 0 ->
            field_thing := (
              Some (
                (
                  Atdgen_runtime.Oj_run.read_int
                ) p lb
              )
            );
          | _ -> (
              Yojson.Safe.skip_json p lb
            )
      );
      while true do
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_object_sep p lb;
        Yojson.Safe.read_space p lb;
        let f =
          fun s pos len ->
            if pos < 0 || len < 0 || pos + len > String.length s then
              invalid_arg "out-of-bounds substring position or length";
            if len = 5 && String.unsafe_get s pos = 't' && String.unsafe_get s (pos+1) = 'h' && String.unsafe_get s (pos+2) = 'i' && String.unsafe_get s (pos+3) = 'n' && String.unsafe_get s (pos+4) = 'g' then (
              0
            )
            else (
              -1
            )
        in
        let i = Yojson.Safe.map_ident p f lb in
        Atdgen_runtime.Oj_run.read_until_field_value p lb;
        (
          match i with
            | 0 ->
              field_thing := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_int
                  ) p lb
                )
              );
            | _ -> (
                Yojson.Safe.skip_json p lb
              )
        );
      done;
      assert false;
    with Yojson.End_of_object -> (
        (
          {
            thing = (match !field_thing with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "thing");
          }
         : b)
      )
)
let b_of_string s =
  read_b (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_a : _ -> a -> _ = (
  fun ob (x : a) ->
    Bi_outbuf.add_char ob '{';
    let is_first = ref true in
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"thing\":";
    (
      Yojson.Safe.write_string
    )
      ob x.thing;
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"other_thing\":";
    (
      Yojson.Safe.write_bool
    )
      ob x.other_thing;
    Bi_outbuf.add_char ob '}';
)
let string_of_a ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_a ob x;
  Bi_outbuf.contents ob
let read_a = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    Yojson.Safe.read_lcurl p lb;
    let field_thing = ref (None) in
    let field_other_thing = ref (None) in
    try
      Yojson.Safe.read_space p lb;
      Yojson.Safe.read_object_end lb;
      Yojson.Safe.read_space p lb;
      let f =
        fun s pos len ->
          if pos < 0 || len < 0 || pos + len > String.length s then
            invalid_arg "out-of-bounds substring position or length";
          match len with
            | 5 -> (
                if String.unsafe_get s pos = 't' && String.unsafe_get s (pos+1) = 'h' && String.unsafe_get s (pos+2) = 'i' && String.unsafe_get s (pos+3) = 'n' && String.unsafe_get s (pos+4) = 'g' then (
                  0
                )
                else (
                  -1
                )
              )
            | 11 -> (
                if String.unsafe_get s pos = 'o' && String.unsafe_get s (pos+1) = 't' && String.unsafe_get s (pos+2) = 'h' && String.unsafe_get s (pos+3) = 'e' && String.unsafe_get s (pos+4) = 'r' && String.unsafe_get s (pos+5) = '_' && String.unsafe_get s (pos+6) = 't' && String.unsafe_get s (pos+7) = 'h' && String.unsafe_get s (pos+8) = 'i' && String.unsafe_get s (pos+9) = 'n' && String.unsafe_get s (pos+10) = 'g' then (
                  1
                )
                else (
                  -1
                )
              )
            | _ -> (
                -1
              )
      in
      let i = Yojson.Safe.map_ident p f lb in
      Atdgen_runtime.Oj_run.read_until_field_value p lb;
      (
        match i with
          | 0 ->
            field_thing := (
              Some (
                (
                  Atdgen_runtime.Oj_run.read_string
                ) p lb
              )
            );
          | 1 ->
            field_other_thing := (
              Some (
                (
                  Atdgen_runtime.Oj_run.read_bool
                ) p lb
              )
            );
          | _ -> (
              Yojson.Safe.skip_json p lb
            )
      );
      while true do
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_object_sep p lb;
        Yojson.Safe.read_space p lb;
        let f =
          fun s pos len ->
            if pos < 0 || len < 0 || pos + len > String.length s then
              invalid_arg "out-of-bounds substring position or length";
            match len with
              | 5 -> (
                  if String.unsafe_get s pos = 't' && String.unsafe_get s (pos+1) = 'h' && String.unsafe_get s (pos+2) = 'i' && String.unsafe_get s (pos+3) = 'n' && String.unsafe_get s (pos+4) = 'g' then (
                    0
                  )
                  else (
                    -1
                  )
                )
              | 11 -> (
                  if String.unsafe_get s pos = 'o' && String.unsafe_get s (pos+1) = 't' && String.unsafe_get s (pos+2) = 'h' && String.unsafe_get s (pos+3) = 'e' && String.unsafe_get s (pos+4) = 'r' && String.unsafe_get s (pos+5) = '_' && String.unsafe_get s (pos+6) = 't' && String.unsafe_get s (pos+7) = 'h' && String.unsafe_get s (pos+8) = 'i' && String.unsafe_get s (pos+9) = 'n' && String.unsafe_get s (pos+10) = 'g' then (
                    1
                  )
                  else (
                    -1
                  )
                )
              | _ -> (
                  -1
                )
        in
        let i = Yojson.Safe.map_ident p f lb in
        Atdgen_runtime.Oj_run.read_until_field_value p lb;
        (
          match i with
            | 0 ->
              field_thing := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_string
                  ) p lb
                )
              );
            | 1 ->
              field_other_thing := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_bool
                  ) p lb
                )
              );
            | _ -> (
                Yojson.Safe.skip_json p lb
              )
        );
      done;
      assert false;
    with Yojson.End_of_object -> (
        (
          {
            thing = (match !field_thing with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "thing");
            other_thing = (match !field_other_thing with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "other_thing");
          }
         : a)
      )
)
let a_of_string s =
  read_a (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_adapted = (
  Atdgen_runtime.Oj_run.write_with_adapter Atdgen_codec_runtime.Json_adapter.Type_field.restore (
    fun ob x ->
      match x with
        | `A x ->
          Bi_outbuf.add_string ob "[\"A\",";
          (
            write_a
          ) ob x;
          Bi_outbuf.add_char ob ']'
        | `B x ->
          Bi_outbuf.add_string ob "[\"B\",";
          (
            write_b
          ) ob x;
          Bi_outbuf.add_char ob ']'
  )
)
let string_of_adapted ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_adapted ob x;
  Bi_outbuf.contents ob
let read_adapted = (
  Atdgen_runtime.Oj_run.read_with_adapter Atdgen_codec_runtime.Json_adapter.Type_field.normalize (
    fun p lb ->
      Yojson.Safe.read_space p lb;
      match Yojson.Safe.start_any_variant p lb with
        | `Edgy_bracket -> (
            match Yojson.Safe.read_ident p lb with
              | "A" ->
                Atdgen_runtime.Oj_run.read_until_field_value p lb;
                let x = (
                    read_a
                  ) p lb
                in
                Yojson.Safe.read_space p lb;
                Yojson.Safe.read_gt p lb;
                `A x
              | "B" ->
                Atdgen_runtime.Oj_run.read_until_field_value p lb;
                let x = (
                    read_b
                  ) p lb
                in
                Yojson.Safe.read_space p lb;
                Yojson.Safe.read_gt p lb;
                `B x
              | x ->
                Atdgen_runtime.Oj_run.invalid_variant_tag p x
          )
        | `Double_quote -> (
            match Yojson.Safe.finish_string p lb with
              | x ->
                Atdgen_runtime.Oj_run.invalid_variant_tag p x
          )
        | `Square_bracket -> (
            match Atdgen_runtime.Oj_run.read_string p lb with
              | "A" ->
                Yojson.Safe.read_space p lb;
                Yojson.Safe.read_comma p lb;
                Yojson.Safe.read_space p lb;
                let x = (
                    read_a
                  ) p lb
                in
                Yojson.Safe.read_space p lb;
                Yojson.Safe.read_rbr p lb;
                `A x
              | "B" ->
                Yojson.Safe.read_space p lb;
                Yojson.Safe.read_comma p lb;
                Yojson.Safe.read_space p lb;
                let x = (
                    read_b
                  ) p lb
                in
                Yojson.Safe.read_space p lb;
                Yojson.Safe.read_rbr p lb;
                `B x
              | x ->
                Atdgen_runtime.Oj_run.invalid_variant_tag p x
          )
  )
)
let adapted_of_string s =
  read_adapted (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
atd-2.1.0/atdgen/test/bucklescript/bucklespec_roundtrip.ml000066400000000000000000000100331357165332000237570ustar00rootroot00000000000000
type 'a test =
  { name: string
  ; to_yojson : 'a -> Yojson.Safe.t
  ; of_yojson : Yojson.Safe.t -> 'a
  ; data: 'a
  }

type test' = T : 'a test -> test'

type failure =
  { name: string
  ; actual: Yojson.Safe.t
  ; received: (Yojson.Safe.t, (exn * string)) result
  }

let pp_json fmt json =
  Format.pp_print_string fmt (Yojson.Safe.pretty_to_string ~std:true json)

let pp_received fmt = function
  | Error (e, bt) ->
      Format.fprintf fmt "exn: %s@.backtrace:@.%s"
        (Printexc.to_string e) bt
  | Ok json -> pp_json fmt json

let test_decode ~name ~yojson ~buckle ~data =
  T { name
    ; to_yojson = (fun a -> Yojson.Safe.from_string (yojson a))
    ; of_yojson = Atdgen_codec_runtime.Decode.decode buckle
    ; data
    }

let test_encode ~name ~yojson ~buckle ~data =
  T { name
    ; to_yojson = Atdgen_codec_runtime.Encode.encode buckle
    ; of_yojson = (fun j -> yojson (Yojson.Safe.to_string ~std:false j))
    ; data
    }

let run_test (T t) =
  let json = t.to_yojson t.data in
  let data' =
    try
      Ok (t.of_yojson json)
    with e ->
      Error (e, Printexc.get_backtrace ())
  in
  if Ok t.data = data' then (
    Ok ()
  ) else (
    Error (
      { name = t.name
      ; actual = json
      ; received =
          (match data' with
           | Ok d -> Ok (t.to_yojson d)
           | Error e -> Error e)
      }
    )
  )

let run_tests tests =
  let failures =
    tests
    |> List.fold_left (fun failures t ->
      match run_test t with
      | Ok () -> failures
      | Error fmt -> fmt::failures
    ) [] in
  match failures with
  | [] -> exit 0
  | xs ->
      begin
        xs
        |> List.iter (fun f ->
          Format.eprintf
            "%s: Roundtrip failed.@.Have:%a@.Decoded:%a@."
            f.name
            pp_json f.actual
            pp_received f.received
        );
        exit 1
      end

let () =
  run_tests
    [ test_decode ~name:"decode record"
        ~yojson:Bucklespec_j.string_of_labeled
        ~buckle:Bucklespec_bs.read_labeled
        ~data:{ Bucklespec_t.
                flag = false
              ; lb = "foo bar"
              ; count = 123
              }
    ; test_encode ~name:"encode record"
        ~yojson:Bucklespec_j.labeled_of_string
        ~buckle:Bucklespec_bs.write_labeled
        ~data:{ Bucklespec_t.
                flag = false
              ; lb = "foo bar"
              ; count = 123
              }
    ; test_decode ~name:"decode variant"
        ~yojson:Bucklespec_j.string_of_simple_vars
        ~buckle:Bucklespec_bs.read_simple_vars
        ~data:[ `Foo (123, 456)
              ; `Bar
              ; `Foobar ()
              ; `Foo_id (`Id "testing")
              ]
    ; test_encode ~name:"encode variant"
        ~yojson:Bucklespec_j.simple_vars_of_string
        ~buckle:Bucklespec_bs.write_simple_vars
        ~data:[ `Foo (123, 456)
              ; `Bar
              ; `Foobar ()
              ; `Foo_id (`Id "testing")
              ]
    ; test_encode ~name:"encode 1 tuple"
        ~yojson:Bucklespec_j.single_tuple_of_string
        ~buckle:Bucklespec_bs.write_single_tuple
        ~data:(`Single_tuple (123))
    ; test_decode ~name:"decode adapted variant a"
        ~yojson:Bucklespec_j.string_of_adapted
        ~buckle:Bucklespec_bs.read_adapted
        ~data: Bucklespec_t.(
          `A ({
            thing = "thing";
            other_thing = false;
          }))
    ; test_encode ~name:"encode adapted variant a"
        ~yojson:Bucklespec_j.adapted_of_string
        ~buckle:Bucklespec_bs.write_adapted
        ~data: Bucklespec_t.(
          `A ({
            thing = "thing";
            other_thing = false;
          }))
    ; test_decode ~name:"decode adapted variant b"
        ~yojson:Bucklespec_j.string_of_adapted
        ~buckle:Bucklespec_bs.read_adapted
        ~data: Bucklespec_t.(
          `B ({
            thing = 1;
          }))
    ; test_encode ~name:"encode adapted variant b"
        ~yojson:Bucklespec_j.adapted_of_string
        ~buckle:Bucklespec_bs.write_adapted
        ~data: Bucklespec_t.(
          `B ({
            thing = 1;
          }))
    ]
atd-2.1.0/atdgen/test/bucklescript/dune000066400000000000000000000020401357165332000200540ustar00rootroot00000000000000(rule
 (targets bucklespec_bs.ml bucklespec_bs.mli)
 (deps bucklespec.atd)
 (action (run atdgen %{deps} -bs)))

(rule
 (targets bucklespec_t.ml bucklespec_t.mli)
 (deps bucklespec.atd)
 (action (run atdgen %{deps} -t)))

(rule
 (targets bucklespec_j.ml bucklespec_j.mli)
 (deps bucklespec.atd)
 (action (run atdgen %{deps} -j -j-std)))

(library
 (name bucklespec_types)
 (wrapped false)
 (libraries atdgen-codec-runtime)
 (modules bucklespec_t a_t a_bs))

(library
 (name bucklespec_bs)
 (wrapped false)
 (libraries atdgen-codec-runtime bucklespec_types)
 (modules bucklespec_bs))

(executable
 (name bucklespec_roundtrip)
 (modules bucklespec_roundtrip bucklespec_j a_j)
 (libraries bucklespec_types bucklespec_bs atdgen-runtime))

(alias
 (name runtest)
 (action (diff bucklespec_bs.expected.ml bucklespec_bs.ml)))

(alias
 (name runtest)
 (action (diff bucklespec_bs.expected.mli bucklespec_bs.mli)))

(alias
 (name runtest)
 (action (diff bucklespec_j.expected.ml bucklespec_j.ml)))

(alias
 (name runtest)
 (action (run ./bucklespec_roundtrip.exe)))
atd-2.1.0/atdgen/test/dune000066400000000000000000000077401357165332000153760ustar00rootroot00000000000000(rule
 (targets test.ml test.mli)
 (deps    test.atd)
 (action  (run %{bin:atdgen} %{deps})))

(alias
 (name runtest)
 (package atdgen)
 (action (diff test.expected.ml test.ml)))

(alias
 (name runtest)
 (package atdgen)
 (action (diff test.expected.mli test.mli)))

(rule
 (targets test2.ml test2.mli)
 (deps    test2.atd)
 (action  (run %{bin:atdgen} -open Test %{deps})))

(alias
 (name runtest)
 (package atdgen)
 (action (diff test2.expected.ml test2.ml)))

(alias
 (name runtest)
 (package atdgen)
 (action (diff test2.expected.mli test2.mli)))

(rule
 (targets testj.ml testj.mli)
 (deps    (:atd test.atd) test.ml test.mli)
 (action
  (run
   %{bin:atdgen} -json -extend Test -j-custom-fields
   "fun loc s -> Printf.eprintf \"Warning: skipping field %s (def: %s)\n\" s loc"
   %{atd}
    -o testj)))

(alias
 (name runtest)
 (package atdgen)
 (action (diff testj.expected.ml testj.ml)))

(alias
 (name runtest)
 (package atdgen)
 (action (diff testj.expected.mli testj.mli)))

(rule
 (targets test2j.ml test2j.mli)
 (deps    test2.atd)
 (action
  (run %{bin:atdgen} -json -std-json -o test2j -open Test,Test2,Testj -ntd %{deps})))

(rule
 (targets test_ambiguous_record_t.ml test_ambiguous_record_t.mli)
 (deps    test_ambiguous_record.atd)
 (action
  (run %{bin:atdgen} -t %{deps})))

(rule
 (targets test_ambiguous_record_j.ml test_ambiguous_record_j.mli)
 (deps    test_ambiguous_record.atd)
 (action
  (run %{bin:atdgen} -json -std-json -o test_ambiguous_record_j -open Test_ambiguous_record_t -ntd %{deps})))

(rule
 (targets test_polymorphic_wrap_t.ml test_polymorphic_wrap_t.mli)
 (deps    test_polymorphic_wrap.atd)
 (action
  (run %{bin:atdgen} -t %{deps})))

(rule
 (targets test_polymorphic_wrap_j.ml test_polymorphic_wrap_j.mli)
 (deps    test_polymorphic_wrap.atd)
 (action
  (run %{bin:atdgen} -json -std-json -o test_polymorphic_wrap_j %{deps})))

(alias
 (name runtest)
 (package atdgen)
 (action (diff test2j.expected.ml test2j.ml)))

(alias
 (name runtest)
 (package atdgen)
 (action (diff test2j.expected.mli test2j.mli)))

(rule
 (targets test3j_t.ml test3j_t.mli)
 (deps    test3j.atd)
 (action  (run %{bin:atdgen} -t %{deps})))

(alias
 (name runtest)
 (package atdgen)
 (action (diff test3j_t.expected.ml test3j_t.ml)))

(alias
 (name runtest)
 (package atdgen)
 (action (diff test3j_t.expected.mli test3j_t.mli)))

(rule
 (targets test3j_j.ml test3j_j.mli)
 (deps    test3j.atd)
 (action  (run %{bin:atdgen} -j -j-std %{deps})))

(alias
 (name runtest)
 (package atdgen)
 (action (diff test3j_j.expected.ml test3j_j.ml)))

(alias
 (name runtest)
 (package atdgen)
 (action (diff test3j_j.expected.mli test3j_j.mli)))

(rule
 (targets testjstd.ml testjstd.mli)
 (deps    test.atd)
 (action  (run %{bin:atdgen} -std-json -extend Test test.atd -o testjstd)))

(alias
 (name runtest)
 (package atdgen)
 (action (diff testjstd.expected.ml testjstd.ml)))

(alias
 (name runtest)
 (package atdgen)
 (action (diff testjstd.expected.mli testjstd.mli)))

(rule
 (targets testv.ml testv.mli)
 (deps    test.atd)
 (action  (run %{bin:atdgen} -validate -extend Test test.atd -o testv)))

(alias
 (name runtest)
 (package atdgen)
 (action (diff testv.expected.ml testv.ml)))

(alias
 (name runtest)
 (package atdgen)
 (action (diff testv.expected.mli testv.mli)))

(alias
 (name runtest)
 (package atdgen)
 (action (diff test_ambiguous_record_j.expected.ml test_ambiguous_record_j.ml)))


(alias
 (name runtest)
 (package atdgen)
 (action (diff test_polymorphic_wrap_t.expected.ml test_polymorphic_wrap_t.ml)))

(alias
 (name runtest)
 (package atdgen)
 (action (diff test_polymorphic_wrap_j.expected.ml test_polymorphic_wrap_j.ml)))

(executables
 (libraries atd atdgen-runtime)
 (names test_atdgen_main)
 (modules
  test
  json_adapters
  array_wrap
  test3j_j
  test3j_t
  test_ambiguous_record_t
  test_ambiguous_record_j
  test_polymorphic_wrap_t
  test_polymorphic_wrap_j
  testjstd
  testj
  testv
  test_atdgen_main
  test_atdgen_type_conv
  test_lib))

(alias
 (name   runtest)
 (package atdgen)
 (action (run ./test_atdgen_main.exe)))
atd-2.1.0/atdgen/test/json_adapters.ml000066400000000000000000000001341357165332000176740ustar00rootroot00000000000000(* Json adapters *)

module Identity = struct
  let normalize x = x
  let restore x = x
end
atd-2.1.0/atdgen/test/spec_js/000077500000000000000000000000001357165332000161365ustar00rootroot00000000000000atd-2.1.0/atdgen/test/spec_js/dune000066400000000000000000000016071357165332000170200ustar00rootroot00000000000000(library
 (name spec_js)
 (modules spec_t spec_j spec_js spec_bs)
 (libraries atdgen-runtime atdgen-codec-runtime))

(rule
 (targets spec_t.ml spec_t.mli)
 (deps spec.atd)
 (action (run atdgen %{deps} -t)))

(rule
 (targets spec_j.ml spec_j.mli)
 (deps spec.atd)
 (action (run atdgen %{deps} -j -j-std)))

(rule
 (targets spec_bs.ml spec_bs.mli)
 (deps spec.atd)
 (action (run atdgen %{deps} -bs)))

(executable
 (name test_j)
 (modules test_j)
 (libraries spec_js atdgen-runtime))

(executable
 (name test_bs)
 (modules test_bs)
 (libraries spec_js atdgen-codec-runtime))

(rule
 (targets spec_j.json)
 (action (with-stdout-to %{targets} (run ./test_j.exe))))

(alias
 (name runtest)
 (action (diff spec_j.expected.json spec_j.json)))

(rule
 (targets spec_bs.json)
 (action (with-stdout-to %{targets} (run ./test_bs.exe))))

(alias
 (name runtest)
 (action (diff spec_bs.expected.json spec_bs.json)))
atd-2.1.0/atdgen/test/spec_js/spec.atd000066400000000000000000000020211357165332000175550ustar00rootroot00000000000000type r1 = { r1: string }
type r2 = { r2: int option }
type r3 = { ?r3: int option }
type r4 = { ~r4: bool }
type r5 = { ~r5: int option }
type r6 = { ~r6 : int }
type r7 = { ~r7 : int }
type r8 = { ~r8 : int list }

type j1 = string list
type j2 = unit
type j3 = int list 
type j4 = int 

type o1 = (string * int) list 
type o2 = (string * int) list  

type t1 = (int * string)
type t2 = (int * int *  : int)

type v1 =
  [ V1
  | V2 
  | V3 of string
  | V4 of int 
  | V5 of bool option]

type v1list = v1 list

type v2 =
  { v2 : [ A | B of int ]
  }

type v3 = [ C1 | C2 of bool] 

type v3list = v3 list

type age = int wrap
  

type ages = age list
atd-2.1.0/atdgen/test/spec_js/spec_bs.expected.json000066400000000000000000000012371357165332000222520ustar00rootroot00000000000000[
  { "r1": "testing" },
  { "r2": [ "Some", 2 ] },
  { "r2": "None" },
  { "r3": 3 },
  {},
  { "r4": true },
  { "r5": [ "Some", 5 ] },
  { "r5": "None" },
  { "r6": 6 },
  { "r6": 42 },
  { "r7": -1000 },
  { "r8": [ 1, 2, 3 ] },
  [ "foo", "bar" ],
  [],
  null,
  [ 1, 2, 3 ],
  "c",
  { "baz": 43, "bar": 8, "foo": 7 },
  { "42": 42, "baz2": 41, "bar2": 6, "foo2": 5 },
  [ 100, "foo" ],
  [ 100, 200, 42 ],
  [ 100, 200, -1 ],
  [
    "V1",
    "v22",
    [ "V3", "testing" ],
    [ "V4", 255 ],
    [ "V5", "None" ],
    [ "V5", [ "Some", true ] ]
  ],
  { "v2": "A" },
  { "v2": [ "B", 100 ] },
  [ "C1", [ "C2", true ], [ "C2", false ] ],
  [ 50, 30, 1, 100 ]
]atd-2.1.0/atdgen/test/spec_js/spec_j.expected.json000066400000000000000000000012061357165332000220730ustar00rootroot00000000000000[
  { "r1": "testing" },
  { "r2": [ "Some", 2 ] },
  { "r2": "None" },
  { "r3": 3 },
  {},
  { "r4": true },
  { "r5": [ "Some", 5 ] },
  {},
  { "r6": 6 },
  {},
  { "r7": -1000 },
  { "r8": [ 1, 2, 3 ] },
  [ "foo", "bar" ],
  [],
  null,
  [ 1, 2, 3 ],
  99,
  { "foo": 7, "bar": 8, "baz": 43 },
  { "foo2": 5, "bar2": 6, "baz2": 41, "42": 42 },
  [ 100, "foo" ],
  [ 100, 200, 42 ],
  [ 100, 200, -1 ],
  [
    "V1",
    "v22",
    [ "V3", "testing" ],
    [ "V4", 255 ],
    [ "V5", "None" ],
    [ "V5", [ "Some", true ] ]
  ],
  { "v2": "A" },
  { "v2": [ "B", 100 ] },
  [ "C1", [ "C2", true ], [ "C2", false ] ],
  [ 50, 30, 1, 100 ]
]atd-2.1.0/atdgen/test/spec_js/spec_js.ml000066400000000000000000000030771357165332000201250ustar00rootroot00000000000000module Bs = Spec_bs
module J = Spec_j

open Spec_t

type 'a j = 'a -> Yojson.Safe.t

module type Json = sig
  val r1     : r1 j
  val r2     : r2 j
  val r3     : r3 j
  val r4     : r4 j
  val r5     : r5 j
  val r6     : r6 j
  val r7     : r7 j
  val r8     : r8 j
  val j1     : j1 j
  val j2     : j2 j
  val j3     : j3 j
  val j4     : j4 j
  val o1     : o1 j
  val o2     : o2 j
  val t1     : t1 j
  val t2     : t2 j
  val v1list : v1list j
  val v2     : v2 j
  val v3list : v3list j
  val ages   : ages j
end

module Make (J : Json) = struct
  open J
  let massive_json =
    `List
      [ r1 { r1 = "testing"}
      ; r2 { r2 = Some 2 }
      ; r2 { r2 = None }
      ; r3 { r3 = Some 3 }
      ; r3 { r3 = None }
      ; r4 { r4 = true }
      ; r5 { r5 = Some 5 }
      ; r5 { r5 = None }
      ; r6 { r6 = 6 }
      ; r6 { r6 = 42 }
      ; r7 { r7 = -1_000 }
      ; r8 { r888 = [1; 2; 3] }
      ; j1 ["foo"; "bar"]
      ; j1 []
      ; j2 ()
      ; j3 [|1; 2; 3|]
      ; j4 'c'
      ; o1 [ "foo", 7; "bar", 8; "baz", 43 ]
      ; o2 [| "foo2", 5; "bar2", 6; "baz2", 41; "42", 42 |]
      ; t1 (100, "foo")
      ; t2 (100, 200, 42)
      ; t2 (100, 200, -1)
      ; v1list [ `V1; `V2; `V3 "testing";
                      `V4 255; `V5 None; `V5 (Some true)]
      ; v2 { v2 = `A }
      ; v2 { v2 = `B 100 }
      ; v3list [C1 ; C2 true; C2 false]
      ; ages [ `Age 50; `Age 30; `Age (-1); `Age 400]
      ]

  let pp_json fmt json =
    Format.pp_print_string fmt (Yojson.Safe.pretty_to_string ~std:true json)

  let run () = pp_json Format.std_formatter massive_json
end
atd-2.1.0/atdgen/test/spec_js/test_bs.ml000066400000000000000000000013631357165332000201360ustar00rootroot00000000000000let make = Atdgen_codec_runtime.Encode.encode

module M = Spec_js.Make(struct
    open Spec_js.Bs

    let r1     = make write_r1
    let r2     = make write_r2
    let r3     = make write_r3
    let r4     = make write_r4
    let r5     = make write_r5
    let r6     = make write_r6
    let r7     = make write_r7
    let r8     = make write_r8
    let j1     = make write_j1
    let j2     = make write_j2
    let j3     = make write_j3
    let j4     = make write_j4
    let o1     = make write_o1
    let o2     = make write_o2
    let t1     = make write_t1
    let t2     = make write_t2
    let v1list = make write_v1list
    let v2     = make write_v2
    let v3list = make write_v3list
    let ages   = make write_ages
  end)

let () = M.run ()
atd-2.1.0/atdgen/test/spec_js/test_j.ml000066400000000000000000000014761357165332000177700ustar00rootroot00000000000000open Spec_js.J

let make f x =
  Yojson.Safe.from_string (f x)

module M = Spec_js.Make(struct
    let r1     = make string_of_r1
    let r2     = make string_of_r2
    let r3     = make string_of_r3
    let r4     = make string_of_r4
    let r5     = make string_of_r5
    let r6     = make string_of_r6
    let r7     = make string_of_r7
    let r8     = make string_of_r8
    let j1     = make string_of_j1
    let j2     = make string_of_j2
    let j3     = make string_of_j3
    let j4     = make string_of_j4
    let o1     = make string_of_o1
    let o2     = make string_of_o2
    let t1     = make string_of_t1
    let t2     = make string_of_t2
    let v1list = make string_of_v1list
    let v2     = make string_of_v2
    let v3list = make string_of_v3list
    let ages   = make string_of_ages
  end)

let () = M.run()
atd-2.1.0/atdgen/test/test.atd000066400000000000000000000120331357165332000161600ustar00rootroot00000000000000

type def 
          = abstract
  

type r = {
  a : int ;
  b  : bool;
  c : p;
}

type p =
    [ A | B of r | C ]
    

type star_rating = int 

type p'' = int p'

type 'a p' = [ A | Bb of 'a p' | Ccccc of 'a ] 

type hello = [ Hello of string | World ] 

type tup = (int * test)


type test_variant =
    [ Case1 | Case2 of int | Case3 of string | Case4 of test_variant list ]

type date = (int * int nullable * int nullable)

type floats = {
  f32 : float ;
  f64 : float;
}

type mixed_record = {
  ?field0 : int option;
  ?field1 : float option;
  field2 : string option;
  field3 : int  ;
  field4 : float list ;
  ?field5 : bool option;
  ?field6 : string option;
  field7 : test_variant;
  field8 : string list ;
  field9 : (
    int 
    * int 
    * int  
    * int 

    * int  
    * int  
  );
  field10 : bool;
  ~field11 : bool;
  field12 : unit list;
  field13 : string option list;
  field14 : date;
}

type mixed =
    (mixed_record list  
    * mixed_record list ) list

type test = {
  ?x0 : int option;
  ?x1 : float option;
  x2 : mixed;
  x3 : mixed_record list;
  x4 : int  ;
}

type base = {
  b0 : int;
  b1 : bool;
}

type extended = {
  b0  : int;
  b1  : bool
    ;
  b2  : string;
  ?b3  : string option;
  b4  : string option;
  ~b5  : float;
} 

type val1 = { val1_x : int
               }
type val2 = {
  val2_x : val1;
  ?val2_y : val1 option;
}

type base_tuple = (int * float)
    
type extended_tuple =
    (int
     * float
     *  : bool
     *  : int option
     * string
     *  : string list)

type option_validation =
    int 
      option

type ('x, 'y) poly = {
  fst : 'x list;
  snd : ('x, 'y) poly option;
}


(*
type field_hash_clash = {
  workshop1 : bool;
  examples3 : bool;
}

type variant_hash_clash = [ X_workshop1 | X_examples3 ]
*)

type int_assoc_list =
    (string * int) list 

type int_assoc_array =
    (string * int) list  

type 'a abs1 = 'a list
type 'a abs2 = 'a list
type 'a abs3 = 'a list

type intopt = int option

type int8 = int 
type char = int  
type int32 = int  
type int64 = int  
type 'a array = 'a list 

type id = string  wrap
    failwith \"empty\"
                       | _ -> None">

type json_map = (id * int) list 

type natural = int wrap 
type even_natural = natural wrap 

type some_record = {
  some_field : int 
}
type no_real_wrap = some_record wrap

type unixtime_list = float  list

type precision = {
  sqrt2_5 : float ;
  small_2 : float ;
  large_2 : float ;
}

type 'a generic = { x294623: int; }
type specialized = string generic

type validate_me =
  string
    
      list
        

type validated_string_check = string atd-2.1.0/atdgen/test/test.expected.ml000066400000000000000000004060611357165332000176300ustar00rootroot00000000000000(* Auto-generated from "test.atd" *)
              [@@@ocaml.warning "-27-32-35-39"]

(** This is just a test. *)

type test_variant = [
    `Case1
  | `Case2 of int
  | `Case3 of string
  | `Case4 of test_variant list
]

type ('x, 'y) poly = { fst: 'x list; snd: ('x, 'y) poly option }

type 'a p' =  A | Bb of 'a p' | Ccccc of 'a 

type p = [ `A | `B of r | `C ]

and r = { a: int; mutable b: bool; c: p }

type validated_string_check = string

type validate_me = string list

type val1 = { val1_x: int }

type val2 = { val2_x: val1; val2_y: val1 option }

type unixtime_list = float list

type date = (int * int option * int option)

type mixed_record = {
  field0: int option;
  field1: float option;
  field2: string option;
  field3: Int64.t;
  field4: float Atdgen_runtime.Util.ocaml_array;
  field5: bool option;
  field6: string option;
  field7: test_variant;
  field8: string Atdgen_runtime.Util.ocaml_array;
  field9: (int * int * Char.t * int * Int32.t * Int64.t);
  field10: bool;
  field11: bool;
  field12: unit list;
  field13: string option list;
  field14: date
}

type mixed =
  (
      mixed_record Atdgen_runtime.Util.ocaml_array
    * mixed_record Atdgen_runtime.Util.ocaml_array
  ) list

type test = {
  x0: int option;
  x1: float option;
  x2: mixed;
  x3: mixed_record list;
  x4: Int64.t
}

type tup = (int * test)

type star_rating = int

type 'a generic = { x294623: int }

type specialized = string generic

type some_record = { some_field: int }

type precision = { sqrt2_5: float; small_2: float; large_2: float }

type p'' = int p'

type option_validation = int option

type no_real_wrap = some_record

type natural = Test_lib.Natural.t

type id = [ `Id of string ]

type json_map = (id * int) list

type intopt = int option

type int_assoc_list = (string * int) list

type int_assoc_array = (string * int) Atdgen_runtime.Util.ocaml_array

type int8 = int

type int64 = Int64.t

type int32 = Int32.t

type hello = [ `Hello of string | `World ]

type floats = { f32: float; f64: float }

type extended_tuple = (
    int
  * float
  * bool
  * int option
  * string
  * string list
)

type extended = {
  b0x (*atd b0 *): int;
  b1x (*atd b1 *): bool;
  b2x (*atd b2 *): string;
  b3x (*atd b3 *): string option;
  b4x (*atd b4 *): string option;
  b5x (*atd b5 *): float
}

type even_natural = Test_lib.Even_natural.t

(**
  \}\}\}abc[def]ghi
  
{v
j  *  j
 k * k
  l*l
v}
  
{v
mno
v}
  
  [pqr]\{stu\}vwx
  
  yz
  
  [\} \[ \] \{v]
  
{v
\} [x] v\} \{v [ @ 
v}
*)
type def = Test_lib.Biniou.def

type char = Char.t

type base_tuple = (int * float)

type base = { b0: int; b1: bool }

type 'a array = 'a Atdgen_runtime.Util.ocaml_array

type 'a abs3 = 'a list

type 'a abs2 = 'a list

type 'a abs1 = 'a list

let _19_tag = Bi_io.array_tag
let write_untagged__19 _a_tag write_untagged__a write__a = (
  Atdgen_runtime.Ob_run.write_untagged_list
    _a_tag
    (
      write_untagged__a
    )
)
let write__19 _a_tag write_untagged__a write__a ob x =
  Bi_io.write_tag ob Bi_io.array_tag;
  write_untagged__19 _a_tag write_untagged__a write__a ob x
let string_of__19 _a_tag write_untagged__a write__a ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__19 _a_tag write_untagged__a write__a ob x;
  Bi_outbuf.contents ob
let get__19_reader get__a_reader read__a = (
  Atdgen_runtime.Ob_run.get_list_reader (
    get__a_reader
  )
)
let read__19 get__a_reader read__a = (
  Atdgen_runtime.Ob_run.read_list (
    get__a_reader
  )
)
let _19_of_string get__a_reader read__a ?pos s =
  read__19 get__a_reader read__a (Bi_inbuf.from_string ?pos s)
let rec p'_tag = Bi_io.variant_tag
and write_untagged_p' _a_tag write_untagged__a write__a : Bi_outbuf.t -> 'a p' -> unit = (
  fun ob x ->
    match x with
      | A -> Bi_outbuf.add_char4 ob '\000' '\000' '\000' 'A'
      | Bb x ->
        Bi_outbuf.add_char4 ob '\128' '\000' '9' '\224';
        (
          write_p' _a_tag write_untagged__a write__a
        ) ob x
      | Ccccc x ->
        Bi_outbuf.add_char4 ob '\213' '\148' 's' '\003';
        (
          write__a
        ) ob x
)
and write_p' _a_tag write_untagged__a write__a ob x =
  Bi_io.write_tag ob Bi_io.variant_tag;
  write_untagged_p' _a_tag write_untagged__a write__a ob x
and string_of_p' _a_tag write_untagged__a write__a ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_p' _a_tag write_untagged__a write__a ob x;
  Bi_outbuf.contents ob
let rec get_p'_reader get__a_reader read__a = (
  fun tag ->
    if tag <> 23 then Atdgen_runtime.Ob_run.read_error () else
      fun ib ->
        Bi_io.read_hashtag ib (fun ib h has_arg ->
          match h, has_arg with
            | 65, false -> (A : 'a p')
            | 14816, true -> (Bb (
                (
                  read_p' get__a_reader read__a
                ) ib
              ) : 'a p')
            | -711691517, true -> (Ccccc (
                (
                  read__a
                ) ib
              ) : 'a p')
            | _ -> Atdgen_runtime.Ob_run.unsupported_variant h has_arg
        )
)
and read_p' get__a_reader read__a = (
  fun ib ->
    if Bi_io.read_tag ib <> 23 then Atdgen_runtime.Ob_run.read_error_at ib;
    Bi_io.read_hashtag ib (fun ib h has_arg ->
      match h, has_arg with
        | 65, false -> (A : 'a p')
        | 14816, true -> (Bb (
            (
              read_p' get__a_reader read__a
            ) ib
          ) : 'a p')
        | -711691517, true -> (Ccccc (
            (
              read__a
            ) ib
          ) : 'a p')
        | _ -> Atdgen_runtime.Ob_run.unsupported_variant h has_arg
    )
)
and p'_of_string get__a_reader read__a ?pos s =
  read_p' get__a_reader read__a (Bi_inbuf.from_string ?pos s)
let rec p_tag = Bi_io.variant_tag
and write_untagged_p = (
  fun ob x ->
    match x with
      | `A -> Bi_outbuf.add_char4 ob '\000' '\000' '\000' 'A'
      | `B x ->
        Bi_outbuf.add_char4 ob '\128' '\000' '\000' 'B';
        (
          write_r
        ) ob x
      | `C -> Bi_outbuf.add_char4 ob '\000' '\000' '\000' 'C'
)
and write_p ob x =
  Bi_io.write_tag ob Bi_io.variant_tag;
  write_untagged_p ob x
and string_of_p ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_p ob x;
  Bi_outbuf.contents ob
and r_tag = Bi_io.record_tag
and write_untagged_r : Bi_outbuf.t -> r -> unit = (
  fun ob x ->
    Bi_vint.write_uvint ob 3;
    Bi_outbuf.add_char4 ob '\128' '\000' '\000' 'a';
    (
      Bi_io.write_svint
    ) ob x.a;
    Bi_outbuf.add_char4 ob '\128' '\000' '\000' 'b';
    (
      Bi_io.write_bool
    ) ob x.b;
    Bi_outbuf.add_char4 ob '\128' '\000' '\000' 'c';
    (
      write_p
    ) ob x.c;
)
and write_r ob x =
  Bi_io.write_tag ob Bi_io.record_tag;
  write_untagged_r ob x
and string_of_r ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_r ob x;
  Bi_outbuf.contents ob
let rec get_p_reader = (
  fun tag ->
    if tag <> 23 then Atdgen_runtime.Ob_run.read_error () else
      fun ib ->
        Bi_io.read_hashtag ib (fun ib h has_arg ->
          match h, has_arg with
            | 65, false -> `A
            | 66, true -> (`B (
                (
                  read_r
                ) ib
              ))
            | 67, false -> `C
            | _ -> Atdgen_runtime.Ob_run.unsupported_variant h has_arg
        )
)
and read_p = (
  fun ib ->
    if Bi_io.read_tag ib <> 23 then Atdgen_runtime.Ob_run.read_error_at ib;
    Bi_io.read_hashtag ib (fun ib h has_arg ->
      match h, has_arg with
        | 65, false -> `A
        | 66, true -> (`B (
            (
              read_r
            ) ib
          ))
        | 67, false -> `C
        | _ -> Atdgen_runtime.Ob_run.unsupported_variant h has_arg
    )
)
and p_of_string ?pos s =
  read_p (Bi_inbuf.from_string ?pos s)
and get_r_reader = (
  fun tag ->
    if tag <> 21 then Atdgen_runtime.Ob_run.read_error () else
      fun ib ->
        let field_a = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let field_b = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let field_c = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let bits0 = ref 0 in
        let len = Bi_vint.read_uvint ib in
        for i = 1 to len do
          match Bi_io.read_field_hashtag ib with
            | 97 ->
              field_a := (
                (
                  Atdgen_runtime.Ob_run.read_int
                ) ib
              );
              bits0 := !bits0 lor 0x1;
            | 98 ->
              field_b := (
                (
                  Atdgen_runtime.Ob_run.read_bool
                ) ib
              );
              bits0 := !bits0 lor 0x2;
            | 99 ->
              field_c := (
                (
                  read_p
                ) ib
              );
              bits0 := !bits0 lor 0x4;
            | _ -> Bi_io.skip ib
        done;
        if !bits0 <> 0x7 then Atdgen_runtime.Ob_run.missing_fields [| !bits0 |] [| "a"; "b"; "c" |];
        (
          {
            a = !field_a;
            b = !field_b;
            c = !field_c;
          }
         : r)
)
and read_r = (
  fun ib ->
    if Bi_io.read_tag ib <> 21 then Atdgen_runtime.Ob_run.read_error_at ib;
    let field_a = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let field_b = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let field_c = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let bits0 = ref 0 in
    let len = Bi_vint.read_uvint ib in
    for i = 1 to len do
      match Bi_io.read_field_hashtag ib with
        | 97 ->
          field_a := (
            (
              Atdgen_runtime.Ob_run.read_int
            ) ib
          );
          bits0 := !bits0 lor 0x1;
        | 98 ->
          field_b := (
            (
              Atdgen_runtime.Ob_run.read_bool
            ) ib
          );
          bits0 := !bits0 lor 0x2;
        | 99 ->
          field_c := (
            (
              read_p
            ) ib
          );
          bits0 := !bits0 lor 0x4;
        | _ -> Bi_io.skip ib
    done;
    if !bits0 <> 0x7 then Atdgen_runtime.Ob_run.missing_fields [| !bits0 |] [| "a"; "b"; "c" |];
    (
      {
        a = !field_a;
        b = !field_b;
        c = !field_c;
      }
     : r)
)
and r_of_string ?pos s =
  read_r (Bi_inbuf.from_string ?pos s)
let rec _20_tag = Bi_io.num_variant_tag
and write_untagged__20 _a_tag write_untagged__a write__a _b_tag write_untagged__b write__b ob x = (
  Atdgen_runtime.Ob_run.write_untagged_option (
    write_poly _a_tag write_untagged__a write__a _b_tag write_untagged__b write__b
  )
) ob x
and write__20 _a_tag write_untagged__a write__a _b_tag write_untagged__b write__b ob x =
  Bi_io.write_tag ob Bi_io.num_variant_tag;
  write_untagged__20 _a_tag write_untagged__a write__a _b_tag write_untagged__b write__b ob x
and string_of__20 _a_tag write_untagged__a write__a _b_tag write_untagged__b write__b ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__20 _a_tag write_untagged__a write__a _b_tag write_untagged__b write__b ob x;
  Bi_outbuf.contents ob
and poly_tag = Bi_io.record_tag
and write_untagged_poly _x_tag write_untagged__x write__x _y_tag write_untagged__y write__y : Bi_outbuf.t -> ('x, 'y) poly -> unit = (
  fun ob x ->
    Bi_vint.write_uvint ob 2;
    Bi_outbuf.add_char4 ob '\128' 'M' '\202' '\135';
    (
      write__19 _x_tag write_untagged__x write__x
    ) ob x.fst;
    Bi_outbuf.add_char4 ob '\128' 'W' '\163' 'i';
    (
      write__20 _x_tag write_untagged__x write__x _y_tag write_untagged__y write__y
    ) ob x.snd;
)
and write_poly _x_tag write_untagged__x write__x _y_tag write_untagged__y write__y ob x =
  Bi_io.write_tag ob Bi_io.record_tag;
  write_untagged_poly _x_tag write_untagged__x write__x _y_tag write_untagged__y write__y ob x
and string_of_poly _x_tag write_untagged__x write__x _y_tag write_untagged__y write__y ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_poly _x_tag write_untagged__x write__x _y_tag write_untagged__y write__y ob x;
  Bi_outbuf.contents ob
let rec get__20_reader get__a_reader read__a get__b_reader read__b = (
  fun tag ->
    if tag <> 22 then Atdgen_runtime.Ob_run.read_error () else
      fun ib ->
        match Char.code (Bi_inbuf.read_char ib) with
          | 0 -> None
          | 0x80 ->
            Some (
              (
                read_poly get__a_reader read__a get__b_reader read__b
              )
                ib
            )
          | _ -> Atdgen_runtime.Ob_run.read_error_at ib
)
and read__20 get__a_reader read__a get__b_reader read__b = (
  fun ib ->
    if Bi_io.read_tag ib <> 22 then Atdgen_runtime.Ob_run.read_error_at ib;
    match Char.code (Bi_inbuf.read_char ib) with
      | 0 -> None
      | 0x80 ->
        Some (
          (
            read_poly get__a_reader read__a get__b_reader read__b
          )
            ib
        )
      | _ -> Atdgen_runtime.Ob_run.read_error_at ib
)
and _20_of_string get__a_reader read__a get__b_reader read__b ?pos s =
  read__20 get__a_reader read__a get__b_reader read__b (Bi_inbuf.from_string ?pos s)
and get_poly_reader get__x_reader read__x get__y_reader read__y = (
  fun tag ->
    if tag <> 21 then Atdgen_runtime.Ob_run.read_error () else
      fun ib ->
        let field_fst = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let field_snd = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let bits0 = ref 0 in
        let len = Bi_vint.read_uvint ib in
        for i = 1 to len do
          match Bi_io.read_field_hashtag ib with
            | 5098119 ->
              field_fst := (
                (
                  read__19 get__x_reader read__x
                ) ib
              );
              bits0 := !bits0 lor 0x1;
            | 5743465 ->
              field_snd := (
                (
                  read__20 get__x_reader read__x get__y_reader read__y
                ) ib
              );
              bits0 := !bits0 lor 0x2;
            | _ -> Bi_io.skip ib
        done;
        if !bits0 <> 0x3 then Atdgen_runtime.Ob_run.missing_fields [| !bits0 |] [| "fst"; "snd" |];
        (
          {
            fst = !field_fst;
            snd = !field_snd;
          }
         : ('x, 'y) poly)
)
and read_poly get__x_reader read__x get__y_reader read__y = (
  fun ib ->
    if Bi_io.read_tag ib <> 21 then Atdgen_runtime.Ob_run.read_error_at ib;
    let field_fst = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let field_snd = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let bits0 = ref 0 in
    let len = Bi_vint.read_uvint ib in
    for i = 1 to len do
      match Bi_io.read_field_hashtag ib with
        | 5098119 ->
          field_fst := (
            (
              read__19 get__x_reader read__x
            ) ib
          );
          bits0 := !bits0 lor 0x1;
        | 5743465 ->
          field_snd := (
            (
              read__20 get__x_reader read__x get__y_reader read__y
            ) ib
          );
          bits0 := !bits0 lor 0x2;
        | _ -> Bi_io.skip ib
    done;
    if !bits0 <> 0x3 then Atdgen_runtime.Ob_run.missing_fields [| !bits0 |] [| "fst"; "snd" |];
    (
      {
        fst = !field_fst;
        snd = !field_snd;
      }
     : ('x, 'y) poly)
)
and poly_of_string get__x_reader read__x get__y_reader read__y ?pos s =
  read_poly get__x_reader read__x get__y_reader read__y (Bi_inbuf.from_string ?pos s)
let rec _2_tag = Bi_io.array_tag
and write_untagged__2 ob x = (
  Atdgen_runtime.Ob_run.write_untagged_list
    test_variant_tag
    (
      write_untagged_test_variant
    )
) ob x
and write__2 ob x =
  Bi_io.write_tag ob Bi_io.array_tag;
  write_untagged__2 ob x
and string_of__2 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__2 ob x;
  Bi_outbuf.contents ob
and test_variant_tag = Bi_io.variant_tag
and write_untagged_test_variant = (
  fun ob x ->
    match x with
      | `Case1 -> Bi_outbuf.add_char4 ob 'T' 'N' '+' 'a'
      | `Case2 x ->
        Bi_outbuf.add_char4 ob '\212' 'N' '+' 'b';
        (
          Bi_io.write_svint
        ) ob x
      | `Case3 x ->
        Bi_outbuf.add_char4 ob '\212' 'N' '+' 'c';
        (
          Bi_io.write_string
        ) ob x
      | `Case4 x ->
        Bi_outbuf.add_char4 ob '\212' 'N' '+' 'd';
        (
          write__2
        ) ob x
)
and write_test_variant ob x =
  Bi_io.write_tag ob Bi_io.variant_tag;
  write_untagged_test_variant ob x
and string_of_test_variant ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_test_variant ob x;
  Bi_outbuf.contents ob
let rec get__2_reader tag = (
  Atdgen_runtime.Ob_run.get_list_reader (
    get_test_variant_reader
  )
) tag
and read__2 ib = (
  Atdgen_runtime.Ob_run.read_list (
    get_test_variant_reader
  )
) ib
and _2_of_string ?pos s =
  read__2 (Bi_inbuf.from_string ?pos s)
and get_test_variant_reader = (
  fun tag ->
    if tag <> 23 then Atdgen_runtime.Ob_run.read_error () else
      fun ib ->
        Bi_io.read_hashtag ib (fun ib h has_arg ->
          match h, has_arg with
            | -733074591, false -> `Case1
            | -733074590, true -> (`Case2 (
                (
                  Atdgen_runtime.Ob_run.read_int
                ) ib
              ))
            | -733074589, true -> (`Case3 (
                (
                  Atdgen_runtime.Ob_run.read_string
                ) ib
              ))
            | -733074588, true -> (`Case4 (
                (
                  read__2
                ) ib
              ))
            | _ -> Atdgen_runtime.Ob_run.unsupported_variant h has_arg
        )
)
and read_test_variant = (
  fun ib ->
    if Bi_io.read_tag ib <> 23 then Atdgen_runtime.Ob_run.read_error_at ib;
    Bi_io.read_hashtag ib (fun ib h has_arg ->
      match h, has_arg with
        | -733074591, false -> `Case1
        | -733074590, true -> (`Case2 (
            (
              Atdgen_runtime.Ob_run.read_int
            ) ib
          ))
        | -733074589, true -> (`Case3 (
            (
              Atdgen_runtime.Ob_run.read_string
            ) ib
          ))
        | -733074588, true -> (`Case4 (
            (
              read__2
            ) ib
          ))
        | _ -> Atdgen_runtime.Ob_run.unsupported_variant h has_arg
    )
)
and test_variant_of_string ?pos s =
  read_test_variant (Bi_inbuf.from_string ?pos s)
let rec _1_tag = Bi_io.variant_tag
and write_untagged__1 : Bi_outbuf.t -> _ p' -> unit = (
  fun ob x ->
    match x with
      | A -> Bi_outbuf.add_char4 ob '\000' '\000' '\000' 'A'
      | Bb x ->
        Bi_outbuf.add_char4 ob '\128' '\000' '9' '\224';
        (
          write__1
        ) ob x
      | Ccccc x ->
        Bi_outbuf.add_char4 ob '\213' '\148' 's' '\003';
        (
          Bi_io.write_svint
        ) ob x
)
and write__1 ob x =
  Bi_io.write_tag ob Bi_io.variant_tag;
  write_untagged__1 ob x
and string_of__1 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__1 ob x;
  Bi_outbuf.contents ob
let rec get__1_reader = (
  fun tag ->
    if tag <> 23 then Atdgen_runtime.Ob_run.read_error () else
      fun ib ->
        Bi_io.read_hashtag ib (fun ib h has_arg ->
          match h, has_arg with
            | 65, false -> (A : _ p')
            | 14816, true -> (Bb (
                (
                  read__1
                ) ib
              ) : _ p')
            | -711691517, true -> (Ccccc (
                (
                  Atdgen_runtime.Ob_run.read_int
                ) ib
              ) : _ p')
            | _ -> Atdgen_runtime.Ob_run.unsupported_variant h has_arg
        )
)
and read__1 = (
  fun ib ->
    if Bi_io.read_tag ib <> 23 then Atdgen_runtime.Ob_run.read_error_at ib;
    Bi_io.read_hashtag ib (fun ib h has_arg ->
      match h, has_arg with
        | 65, false -> (A : _ p')
        | 14816, true -> (Bb (
            (
              read__1
            ) ib
          ) : _ p')
        | -711691517, true -> (Ccccc (
            (
              Atdgen_runtime.Ob_run.read_int
            ) ib
          ) : _ p')
        | _ -> Atdgen_runtime.Ob_run.unsupported_variant h has_arg
    )
)
and _1_of_string ?pos s =
  read__1 (Bi_inbuf.from_string ?pos s)
let validated_string_check_tag = Bi_io.string_tag
let write_untagged_validated_string_check = (
  Bi_io.write_untagged_string
)
let write_validated_string_check ob x =
  Bi_io.write_tag ob Bi_io.string_tag;
  write_untagged_validated_string_check ob x
let string_of_validated_string_check ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_validated_string_check ob x;
  Bi_outbuf.contents ob
let get_validated_string_check_reader = (
  Atdgen_runtime.Ob_run.get_string_reader
)
let read_validated_string_check = (
  Atdgen_runtime.Ob_run.read_string
)
let validated_string_check_of_string ?pos s =
  read_validated_string_check (Bi_inbuf.from_string ?pos s)
let _31_tag = Bi_io.array_tag
let write_untagged__31 = (
  Atdgen_runtime.Ob_run.write_untagged_list
    Bi_io.string_tag
    (
      Bi_io.write_untagged_string
    )
)
let write__31 ob x =
  Bi_io.write_tag ob Bi_io.array_tag;
  write_untagged__31 ob x
let string_of__31 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__31 ob x;
  Bi_outbuf.contents ob
let get__31_reader = (
  Atdgen_runtime.Ob_run.get_list_reader (
    Atdgen_runtime.Ob_run.get_string_reader
  )
)
let read__31 = (
  Atdgen_runtime.Ob_run.read_list (
    Atdgen_runtime.Ob_run.get_string_reader
  )
)
let _31_of_string ?pos s =
  read__31 (Bi_inbuf.from_string ?pos s)
let validate_me_tag = Bi_io.array_tag
let write_untagged_validate_me = (
  write_untagged__31
)
let write_validate_me ob x =
  Bi_io.write_tag ob Bi_io.array_tag;
  write_untagged_validate_me ob x
let string_of_validate_me ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_validate_me ob x;
  Bi_outbuf.contents ob
let get_validate_me_reader = (
  get__31_reader
)
let read_validate_me = (
  read__31
)
let validate_me_of_string ?pos s =
  read_validate_me (Bi_inbuf.from_string ?pos s)
let val1_tag = Bi_io.record_tag
let write_untagged_val1 : Bi_outbuf.t -> val1 -> unit = (
  fun ob x ->
    Bi_vint.write_uvint ob 1;
    Bi_outbuf.add_char4 ob '\207' '\131' 'e' 'i';
    (
      Bi_io.write_svint
    ) ob x.val1_x;
)
let write_val1 ob x =
  Bi_io.write_tag ob Bi_io.record_tag;
  write_untagged_val1 ob x
let string_of_val1 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_val1 ob x;
  Bi_outbuf.contents ob
let get_val1_reader = (
  fun tag ->
    if tag <> 21 then Atdgen_runtime.Ob_run.read_error () else
      fun ib ->
        let field_val1_x = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let bits0 = ref 0 in
        let len = Bi_vint.read_uvint ib in
        for i = 1 to len do
          match Bi_io.read_field_hashtag ib with
            | -813472407 ->
              field_val1_x := (
                (
                  Atdgen_runtime.Ob_run.read_int
                ) ib
              );
              bits0 := !bits0 lor 0x1;
            | _ -> Bi_io.skip ib
        done;
        if !bits0 <> 0x1 then Atdgen_runtime.Ob_run.missing_fields [| !bits0 |] [| "val1_x" |];
        (
          {
            val1_x = !field_val1_x;
          }
         : val1)
)
let read_val1 = (
  fun ib ->
    if Bi_io.read_tag ib <> 21 then Atdgen_runtime.Ob_run.read_error_at ib;
    let field_val1_x = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let bits0 = ref 0 in
    let len = Bi_vint.read_uvint ib in
    for i = 1 to len do
      match Bi_io.read_field_hashtag ib with
        | -813472407 ->
          field_val1_x := (
            (
              Atdgen_runtime.Ob_run.read_int
            ) ib
          );
          bits0 := !bits0 lor 0x1;
        | _ -> Bi_io.skip ib
    done;
    if !bits0 <> 0x1 then Atdgen_runtime.Ob_run.missing_fields [| !bits0 |] [| "val1_x" |];
    (
      {
        val1_x = !field_val1_x;
      }
     : val1)
)
let val1_of_string ?pos s =
  read_val1 (Bi_inbuf.from_string ?pos s)
let _16_tag = Bi_io.num_variant_tag
let write_untagged__16 = (
  Atdgen_runtime.Ob_run.write_untagged_option (
    write_val1
  )
)
let write__16 ob x =
  Bi_io.write_tag ob Bi_io.num_variant_tag;
  write_untagged__16 ob x
let string_of__16 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__16 ob x;
  Bi_outbuf.contents ob
let get__16_reader = (
  fun tag ->
    if tag <> 22 then Atdgen_runtime.Ob_run.read_error () else
      fun ib ->
        match Char.code (Bi_inbuf.read_char ib) with
          | 0 -> None
          | 0x80 ->
            Some (
              (
                read_val1
              )
                ib
            )
          | _ -> Atdgen_runtime.Ob_run.read_error_at ib
)
let read__16 = (
  fun ib ->
    if Bi_io.read_tag ib <> 22 then Atdgen_runtime.Ob_run.read_error_at ib;
    match Char.code (Bi_inbuf.read_char ib) with
      | 0 -> None
      | 0x80 ->
        Some (
          (
            read_val1
          )
            ib
        )
      | _ -> Atdgen_runtime.Ob_run.read_error_at ib
)
let _16_of_string ?pos s =
  read__16 (Bi_inbuf.from_string ?pos s)
let val2_tag = Bi_io.record_tag
let write_untagged_val2 : Bi_outbuf.t -> val2 -> unit = (
  fun ob x ->
    let len = ref 1 in
    let x_val2_y = x.val2_y in
    if x_val2_y != None then incr len;
    Bi_vint.write_uvint ob !len;
    Bi_outbuf.add_char4 ob '\207' '\132' '\'' '\170';
    (
      write_val1
    ) ob x.val2_x;
    (match x_val2_y with None -> () | Some x ->
      Bi_outbuf.add_char4 ob '\207' '\132' '\'' '\171';
      (
        write_val1
      ) ob x;
    );
)
let write_val2 ob x =
  Bi_io.write_tag ob Bi_io.record_tag;
  write_untagged_val2 ob x
let string_of_val2 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_val2 ob x;
  Bi_outbuf.contents ob
let get_val2_reader = (
  fun tag ->
    if tag <> 21 then Atdgen_runtime.Ob_run.read_error () else
      fun ib ->
        let field_val2_x = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let field_val2_y = ref (None) in
        let bits0 = ref 0 in
        let len = Bi_vint.read_uvint ib in
        for i = 1 to len do
          match Bi_io.read_field_hashtag ib with
            | -813422678 ->
              field_val2_x := (
                (
                  read_val1
                ) ib
              );
              bits0 := !bits0 lor 0x1;
            | -813422677 ->
              field_val2_y := (
                Some (
                  (
                    read_val1
                  ) ib
                )
              );
            | _ -> Bi_io.skip ib
        done;
        if !bits0 <> 0x1 then Atdgen_runtime.Ob_run.missing_fields [| !bits0 |] [| "val2_x" |];
        (
          {
            val2_x = !field_val2_x;
            val2_y = !field_val2_y;
          }
         : val2)
)
let read_val2 = (
  fun ib ->
    if Bi_io.read_tag ib <> 21 then Atdgen_runtime.Ob_run.read_error_at ib;
    let field_val2_x = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let field_val2_y = ref (None) in
    let bits0 = ref 0 in
    let len = Bi_vint.read_uvint ib in
    for i = 1 to len do
      match Bi_io.read_field_hashtag ib with
        | -813422678 ->
          field_val2_x := (
            (
              read_val1
            ) ib
          );
          bits0 := !bits0 lor 0x1;
        | -813422677 ->
          field_val2_y := (
            Some (
              (
                read_val1
              ) ib
            )
          );
        | _ -> Bi_io.skip ib
    done;
    if !bits0 <> 0x1 then Atdgen_runtime.Ob_run.missing_fields [| !bits0 |] [| "val2_x" |];
    (
      {
        val2_x = !field_val2_x;
        val2_y = !field_val2_y;
      }
     : val2)
)
let val2_of_string ?pos s =
  read_val2 (Bi_inbuf.from_string ?pos s)
let _29_tag = Bi_io.array_tag
let write_untagged__29 = (
  Atdgen_runtime.Ob_run.write_untagged_list
    Bi_io.float64_tag
    (
      Bi_io.write_untagged_float64
    )
)
let write__29 ob x =
  Bi_io.write_tag ob Bi_io.array_tag;
  write_untagged__29 ob x
let string_of__29 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__29 ob x;
  Bi_outbuf.contents ob
let get__29_reader = (
  Atdgen_runtime.Ob_run.get_list_reader (
    Atdgen_runtime.Ob_run.get_float64_reader
  )
)
let read__29 = (
  Atdgen_runtime.Ob_run.read_list (
    Atdgen_runtime.Ob_run.get_float64_reader
  )
)
let _29_of_string ?pos s =
  read__29 (Bi_inbuf.from_string ?pos s)
let unixtime_list_tag = Bi_io.array_tag
let write_untagged_unixtime_list = (
  write_untagged__29
)
let write_unixtime_list ob x =
  Bi_io.write_tag ob Bi_io.array_tag;
  write_untagged_unixtime_list ob x
let string_of_unixtime_list ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_unixtime_list ob x;
  Bi_outbuf.contents ob
let get_unixtime_list_reader = (
  get__29_reader
)
let read_unixtime_list = (
  read__29
)
let unixtime_list_of_string ?pos s =
  read_unixtime_list (Bi_inbuf.from_string ?pos s)
let _3_tag = Bi_io.num_variant_tag
let write_untagged__3 = (
  Atdgen_runtime.Ob_run.write_untagged_option (
    Bi_io.write_svint
  )
)
let write__3 ob x =
  Bi_io.write_tag ob Bi_io.num_variant_tag;
  write_untagged__3 ob x
let string_of__3 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__3 ob x;
  Bi_outbuf.contents ob
let get__3_reader = (
  fun tag ->
    if tag <> 22 then Atdgen_runtime.Ob_run.read_error () else
      fun ib ->
        match Char.code (Bi_inbuf.read_char ib) with
          | 0 -> None
          | 0x80 ->
            Some (
              (
                Atdgen_runtime.Ob_run.read_int
              )
                ib
            )
          | _ -> Atdgen_runtime.Ob_run.read_error_at ib
)
let read__3 = (
  fun ib ->
    if Bi_io.read_tag ib <> 22 then Atdgen_runtime.Ob_run.read_error_at ib;
    match Char.code (Bi_inbuf.read_char ib) with
      | 0 -> None
      | 0x80 ->
        Some (
          (
            Atdgen_runtime.Ob_run.read_int
          )
            ib
        )
      | _ -> Atdgen_runtime.Ob_run.read_error_at ib
)
let _3_of_string ?pos s =
  read__3 (Bi_inbuf.from_string ?pos s)
let date_tag = Bi_io.tuple_tag
let write_untagged_date = (
  fun ob x ->
    Bi_vint.write_uvint ob 3;
    (
      let x, _, _ = x in (
        Bi_io.write_svint
      ) ob x
    );
    (
      let _, x, _ = x in (
        write__3
      ) ob x
    );
    (
      let _, _, x = x in (
        write__3
      ) ob x
    );
)
let write_date ob x =
  Bi_io.write_tag ob Bi_io.tuple_tag;
  write_untagged_date ob x
let string_of_date ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_date ob x;
  Bi_outbuf.contents ob
let get_date_reader = (
  fun tag ->
    if tag <> 20 then Atdgen_runtime.Ob_run.read_error () else
      fun ib ->
        let len = Bi_vint.read_uvint ib in
        if len < 3 then Atdgen_runtime.Ob_run.missing_tuple_fields len [ 0; 1; 2 ];
        let x0 =
          (
            Atdgen_runtime.Ob_run.read_int
          ) ib
        in
        let x1 =
          (
            read__3
          ) ib
        in
        let x2 =
          (
            read__3
          ) ib
        in
        for i = 3 to len - 1 do Bi_io.skip ib done;
        (x0, x1, x2)
)
let read_date = (
  fun ib ->
    if Bi_io.read_tag ib <> 20 then Atdgen_runtime.Ob_run.read_error_at ib;
    let len = Bi_vint.read_uvint ib in
    if len < 3 then Atdgen_runtime.Ob_run.missing_tuple_fields len [ 0; 1; 2 ];
    let x0 =
      (
        Atdgen_runtime.Ob_run.read_int
      ) ib
    in
    let x1 =
      (
        read__3
      ) ib
    in
    let x2 =
      (
        read__3
      ) ib
    in
    for i = 3 to len - 1 do Bi_io.skip ib done;
    (x0, x1, x2)
)
let date_of_string ?pos s =
  read_date (Bi_inbuf.from_string ?pos s)
let _9_tag = Bi_io.array_tag
let write_untagged__9 = (
  Atdgen_runtime.Ob_run.write_untagged_array
    Bi_io.string_tag
    (
      Bi_io.write_untagged_string
    )
)
let write__9 ob x =
  Bi_io.write_tag ob Bi_io.array_tag;
  write_untagged__9 ob x
let string_of__9 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__9 ob x;
  Bi_outbuf.contents ob
let get__9_reader = (
  Atdgen_runtime.Ob_run.get_array_reader (
    Atdgen_runtime.Ob_run.get_string_reader
  )
)
let read__9 = (
  Atdgen_runtime.Ob_run.read_array (
    Atdgen_runtime.Ob_run.get_string_reader
  )
)
let _9_of_string ?pos s =
  read__9 (Bi_inbuf.from_string ?pos s)
let _8_tag = Bi_io.num_variant_tag
let write_untagged__8 = (
  Atdgen_runtime.Ob_run.write_untagged_option (
    Bi_io.write_bool
  )
)
let write__8 ob x =
  Bi_io.write_tag ob Bi_io.num_variant_tag;
  write_untagged__8 ob x
let string_of__8 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__8 ob x;
  Bi_outbuf.contents ob
let get__8_reader = (
  fun tag ->
    if tag <> 22 then Atdgen_runtime.Ob_run.read_error () else
      fun ib ->
        match Char.code (Bi_inbuf.read_char ib) with
          | 0 -> None
          | 0x80 ->
            Some (
              (
                Atdgen_runtime.Ob_run.read_bool
              )
                ib
            )
          | _ -> Atdgen_runtime.Ob_run.read_error_at ib
)
let read__8 = (
  fun ib ->
    if Bi_io.read_tag ib <> 22 then Atdgen_runtime.Ob_run.read_error_at ib;
    match Char.code (Bi_inbuf.read_char ib) with
      | 0 -> None
      | 0x80 ->
        Some (
          (
            Atdgen_runtime.Ob_run.read_bool
          )
            ib
        )
      | _ -> Atdgen_runtime.Ob_run.read_error_at ib
)
let _8_of_string ?pos s =
  read__8 (Bi_inbuf.from_string ?pos s)
let _7_tag = Bi_io.array_tag
let write_untagged__7 = (
  Atdgen_runtime.Ob_run.write_untagged_array
    Bi_io.float64_tag
    (
      Bi_io.write_untagged_float64
    )
)
let write__7 ob x =
  Bi_io.write_tag ob Bi_io.array_tag;
  write_untagged__7 ob x
let string_of__7 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__7 ob x;
  Bi_outbuf.contents ob
let get__7_reader = (
  Atdgen_runtime.Ob_run.get_array_reader (
    Atdgen_runtime.Ob_run.get_float64_reader
  )
)
let read__7 = (
  Atdgen_runtime.Ob_run.read_array (
    Atdgen_runtime.Ob_run.get_float64_reader
  )
)
let _7_of_string ?pos s =
  read__7 (Bi_inbuf.from_string ?pos s)
let _6_tag = Bi_io.num_variant_tag
let write_untagged__6 = (
  Atdgen_runtime.Ob_run.write_untagged_option (
    Bi_io.write_string
  )
)
let write__6 ob x =
  Bi_io.write_tag ob Bi_io.num_variant_tag;
  write_untagged__6 ob x
let string_of__6 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__6 ob x;
  Bi_outbuf.contents ob
let get__6_reader = (
  fun tag ->
    if tag <> 22 then Atdgen_runtime.Ob_run.read_error () else
      fun ib ->
        match Char.code (Bi_inbuf.read_char ib) with
          | 0 -> None
          | 0x80 ->
            Some (
              (
                Atdgen_runtime.Ob_run.read_string
              )
                ib
            )
          | _ -> Atdgen_runtime.Ob_run.read_error_at ib
)
let read__6 = (
  fun ib ->
    if Bi_io.read_tag ib <> 22 then Atdgen_runtime.Ob_run.read_error_at ib;
    match Char.code (Bi_inbuf.read_char ib) with
      | 0 -> None
      | 0x80 ->
        Some (
          (
            Atdgen_runtime.Ob_run.read_string
          )
            ib
        )
      | _ -> Atdgen_runtime.Ob_run.read_error_at ib
)
let _6_of_string ?pos s =
  read__6 (Bi_inbuf.from_string ?pos s)
let _5_tag = Bi_io.num_variant_tag
let write_untagged__5 = (
  Atdgen_runtime.Ob_run.write_untagged_option (
    Bi_io.write_float64
  )
)
let write__5 ob x =
  Bi_io.write_tag ob Bi_io.num_variant_tag;
  write_untagged__5 ob x
let string_of__5 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__5 ob x;
  Bi_outbuf.contents ob
let get__5_reader = (
  fun tag ->
    if tag <> 22 then Atdgen_runtime.Ob_run.read_error () else
      fun ib ->
        match Char.code (Bi_inbuf.read_char ib) with
          | 0 -> None
          | 0x80 ->
            Some (
              (
                Atdgen_runtime.Ob_run.read_float64
              )
                ib
            )
          | _ -> Atdgen_runtime.Ob_run.read_error_at ib
)
let read__5 = (
  fun ib ->
    if Bi_io.read_tag ib <> 22 then Atdgen_runtime.Ob_run.read_error_at ib;
    match Char.code (Bi_inbuf.read_char ib) with
      | 0 -> None
      | 0x80 ->
        Some (
          (
            Atdgen_runtime.Ob_run.read_float64
          )
            ib
        )
      | _ -> Atdgen_runtime.Ob_run.read_error_at ib
)
let _5_of_string ?pos s =
  read__5 (Bi_inbuf.from_string ?pos s)
let _4_tag = Bi_io.num_variant_tag
let write_untagged__4 = (
  Atdgen_runtime.Ob_run.write_untagged_option (
    Bi_io.write_svint
  )
)
let write__4 ob x =
  Bi_io.write_tag ob Bi_io.num_variant_tag;
  write_untagged__4 ob x
let string_of__4 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__4 ob x;
  Bi_outbuf.contents ob
let get__4_reader = (
  fun tag ->
    if tag <> 22 then Atdgen_runtime.Ob_run.read_error () else
      fun ib ->
        match Char.code (Bi_inbuf.read_char ib) with
          | 0 -> None
          | 0x80 ->
            Some (
              (
                Atdgen_runtime.Ob_run.read_int
              )
                ib
            )
          | _ -> Atdgen_runtime.Ob_run.read_error_at ib
)
let read__4 = (
  fun ib ->
    if Bi_io.read_tag ib <> 22 then Atdgen_runtime.Ob_run.read_error_at ib;
    match Char.code (Bi_inbuf.read_char ib) with
      | 0 -> None
      | 0x80 ->
        Some (
          (
            Atdgen_runtime.Ob_run.read_int
          )
            ib
        )
      | _ -> Atdgen_runtime.Ob_run.read_error_at ib
)
let _4_of_string ?pos s =
  read__4 (Bi_inbuf.from_string ?pos s)
let _11_tag = Bi_io.array_tag
let write_untagged__11 = (
  Atdgen_runtime.Ob_run.write_untagged_list
    _6_tag
    (
      write_untagged__6
    )
)
let write__11 ob x =
  Bi_io.write_tag ob Bi_io.array_tag;
  write_untagged__11 ob x
let string_of__11 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__11 ob x;
  Bi_outbuf.contents ob
let get__11_reader = (
  Atdgen_runtime.Ob_run.get_list_reader (
    get__6_reader
  )
)
let read__11 = (
  Atdgen_runtime.Ob_run.read_list (
    get__6_reader
  )
)
let _11_of_string ?pos s =
  read__11 (Bi_inbuf.from_string ?pos s)
let _10_tag = Bi_io.array_tag
let write_untagged__10 = (
  Atdgen_runtime.Ob_run.write_untagged_list
    Bi_io.unit_tag
    (
      Bi_io.write_untagged_unit
    )
)
let write__10 ob x =
  Bi_io.write_tag ob Bi_io.array_tag;
  write_untagged__10 ob x
let string_of__10 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__10 ob x;
  Bi_outbuf.contents ob
let get__10_reader = (
  Atdgen_runtime.Ob_run.get_list_reader (
    Atdgen_runtime.Ob_run.get_unit_reader
  )
)
let read__10 = (
  Atdgen_runtime.Ob_run.read_list (
    Atdgen_runtime.Ob_run.get_unit_reader
  )
)
let _10_of_string ?pos s =
  read__10 (Bi_inbuf.from_string ?pos s)
let mixed_record_tag = Bi_io.record_tag
let write_untagged_mixed_record : Bi_outbuf.t -> mixed_record -> unit = (
  fun ob x ->
    let len = ref 10 in
    let x_field0 = x.field0 in
    if x_field0 != None then incr len;
    let x_field1 = x.field1 in
    if x_field1 != None then incr len;
    let x_field5 = x.field5 in
    if x_field5 != None then incr len;
    let x_field6 = x.field6 in
    if x_field6 != None then incr len;
    let x_field11 = x.field11 in
    if x_field11 != false then incr len;
    Bi_vint.write_uvint ob !len;
    (match x_field0 with None -> () | Some x ->
      Bi_outbuf.add_char4 ob '\128' '\142' '\142' '6';
      (
        Bi_io.write_svint
      ) ob x;
    );
    (match x_field1 with None -> () | Some x ->
      Bi_outbuf.add_char4 ob '\128' '\142' '\142' '7';
      (
        Bi_io.write_float64
      ) ob x;
    );
    Bi_outbuf.add_char4 ob '\128' '\142' '\142' '8';
    (
      write__6
    ) ob x.field2;
    Bi_outbuf.add_char4 ob '\128' '\142' '\142' '9';
    (
      Bi_io.write_int64
    ) ob x.field3;
    Bi_outbuf.add_char4 ob '\128' '\142' '\142' ':';
    (
      write__7
    ) ob x.field4;
    (match x_field5 with None -> () | Some x ->
      Bi_outbuf.add_char4 ob '\128' '\142' '\142' ';';
      (
        Bi_io.write_bool
      ) ob x;
    );
    (match x_field6 with None -> () | Some x ->
      Bi_outbuf.add_char4 ob '\128' '\142' '\142' '<';
      (
        Bi_io.write_string
      ) ob x;
    );
    Bi_outbuf.add_char4 ob '\128' '\142' '\142' '=';
    (
      write_test_variant
    ) ob x.field7;
    Bi_outbuf.add_char4 ob '\128' '\142' '\142' '>';
    (
      write__9
    ) ob x.field8;
    Bi_outbuf.add_char4 ob '\128' '\142' '\142' '?';
    (
      fun ob x ->
        Bi_io.write_tag ob Bi_io.tuple_tag;
        Bi_vint.write_uvint ob 6;
        (
          let x, _, _, _, _, _ = x in (
            Bi_io.write_uvint
          ) ob x
        );
        (
          let _, x, _, _, _, _ = x in (
            Bi_io.write_int8
          ) ob x
        );
        (
          let _, _, x, _, _, _ = x in (
            Bi_io.write_char
          ) ob x
        );
        (
          let _, _, _, x, _, _ = x in (
            Bi_io.write_int16
          ) ob x
        );
        (
          let _, _, _, _, x, _ = x in (
            Bi_io.write_int32
          ) ob x
        );
        (
          let _, _, _, _, _, x = x in (
            Bi_io.write_int64
          ) ob x
        );
    ) ob x.field9;
    Bi_outbuf.add_char4 ob '\252' '-' '\226' '\025';
    (
      Bi_io.write_bool
    ) ob x.field10;
    if x_field11 != false then (
      Bi_outbuf.add_char4 ob '\252' '-' '\226' '\026';
      (
        Bi_io.write_bool
      ) ob x_field11;
    );
    Bi_outbuf.add_char4 ob '\252' '-' '\226' '\027';
    (
      write__10
    ) ob x.field12;
    Bi_outbuf.add_char4 ob '\252' '-' '\226' '\028';
    (
      write__11
    ) ob x.field13;
    Bi_outbuf.add_char4 ob '\252' '-' '\226' '\029';
    (
      write_date
    ) ob x.field14;
)
let write_mixed_record ob x =
  Bi_io.write_tag ob Bi_io.record_tag;
  write_untagged_mixed_record ob x
let string_of_mixed_record ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_mixed_record ob x;
  Bi_outbuf.contents ob
let get_mixed_record_reader = (
  fun tag ->
    if tag <> 21 then Atdgen_runtime.Ob_run.read_error () else
      fun ib ->
        let field_field0 = ref (None) in
        let field_field1 = ref (None) in
        let field_field2 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let field_field3 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let field_field4 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let field_field5 = ref (None) in
        let field_field6 = ref (None) in
        let field_field7 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let field_field8 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let field_field9 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let field_field10 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let field_field11 = ref (false) in
        let field_field12 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let field_field13 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let field_field14 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let bits0 = ref 0 in
        let len = Bi_vint.read_uvint ib in
        for i = 1 to len do
          match Bi_io.read_field_hashtag ib with
            | 9342518 ->
              field_field0 := (
                Some (
                  (
                    Atdgen_runtime.Ob_run.read_int
                  ) ib
                )
              );
            | 9342519 ->
              field_field1 := (
                Some (
                  (
                    Atdgen_runtime.Ob_run.read_float64
                  ) ib
                )
              );
            | 9342520 ->
              field_field2 := (
                (
                  read__6
                ) ib
              );
              bits0 := !bits0 lor 0x1;
            | 9342521 ->
              field_field3 := (
                (
                  Atdgen_runtime.Ob_run.read_int64
                ) ib
              );
              bits0 := !bits0 lor 0x2;
            | 9342522 ->
              field_field4 := (
                (
                  read__7
                ) ib
              );
              bits0 := !bits0 lor 0x4;
            | 9342523 ->
              field_field5 := (
                Some (
                  (
                    Atdgen_runtime.Ob_run.read_bool
                  ) ib
                )
              );
            | 9342524 ->
              field_field6 := (
                Some (
                  (
                    Atdgen_runtime.Ob_run.read_string
                  ) ib
                )
              );
            | 9342525 ->
              field_field7 := (
                (
                  read_test_variant
                ) ib
              );
              bits0 := !bits0 lor 0x8;
            | 9342526 ->
              field_field8 := (
                (
                  read__9
                ) ib
              );
              bits0 := !bits0 lor 0x10;
            | 9342527 ->
              field_field9 := (
                (
                  fun ib ->
                    if Bi_io.read_tag ib <> 20 then Atdgen_runtime.Ob_run.read_error_at ib;
                    let len = Bi_vint.read_uvint ib in
                    if len < 6 then Atdgen_runtime.Ob_run.missing_tuple_fields len [ 0; 1; 2; 3; 4; 5 ];
                    let x0 =
                      (
                        Atdgen_runtime.Ob_run.read_int
                      ) ib
                    in
                    let x1 =
                      (
                        Atdgen_runtime.Ob_run.read_int
                      ) ib
                    in
                    let x2 =
                      (
                        Atdgen_runtime.Ob_run.read_char
                      ) ib
                    in
                    let x3 =
                      (
                        Atdgen_runtime.Ob_run.read_int
                      ) ib
                    in
                    let x4 =
                      (
                        Atdgen_runtime.Ob_run.read_int32
                      ) ib
                    in
                    let x5 =
                      (
                        Atdgen_runtime.Ob_run.read_int64
                      ) ib
                    in
                    for i = 6 to len - 1 do Bi_io.skip ib done;
                    (x0, x1, x2, x3, x4, x5)
                ) ib
              );
              bits0 := !bits0 lor 0x20;
            | -64101863 ->
              field_field10 := (
                (
                  Atdgen_runtime.Ob_run.read_bool
                ) ib
              );
              bits0 := !bits0 lor 0x40;
            | -64101862 ->
              field_field11 := (
                (
                  Atdgen_runtime.Ob_run.read_bool
                ) ib
              );
            | -64101861 ->
              field_field12 := (
                (
                  read__10
                ) ib
              );
              bits0 := !bits0 lor 0x80;
            | -64101860 ->
              field_field13 := (
                (
                  read__11
                ) ib
              );
              bits0 := !bits0 lor 0x100;
            | -64101859 ->
              field_field14 := (
                (
                  read_date
                ) ib
              );
              bits0 := !bits0 lor 0x200;
            | _ -> Bi_io.skip ib
        done;
        if !bits0 <> 0x3ff then Atdgen_runtime.Ob_run.missing_fields [| !bits0 |] [| "field2"; "field3"; "field4"; "field7"; "field8"; "field9"; "field10"; "field12"; "field13"; "field14" |];
        (
          {
            field0 = !field_field0;
            field1 = !field_field1;
            field2 = !field_field2;
            field3 = !field_field3;
            field4 = !field_field4;
            field5 = !field_field5;
            field6 = !field_field6;
            field7 = !field_field7;
            field8 = !field_field8;
            field9 = !field_field9;
            field10 = !field_field10;
            field11 = !field_field11;
            field12 = !field_field12;
            field13 = !field_field13;
            field14 = !field_field14;
          }
         : mixed_record)
)
let read_mixed_record = (
  fun ib ->
    if Bi_io.read_tag ib <> 21 then Atdgen_runtime.Ob_run.read_error_at ib;
    let field_field0 = ref (None) in
    let field_field1 = ref (None) in
    let field_field2 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let field_field3 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let field_field4 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let field_field5 = ref (None) in
    let field_field6 = ref (None) in
    let field_field7 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let field_field8 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let field_field9 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let field_field10 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let field_field11 = ref (false) in
    let field_field12 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let field_field13 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let field_field14 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let bits0 = ref 0 in
    let len = Bi_vint.read_uvint ib in
    for i = 1 to len do
      match Bi_io.read_field_hashtag ib with
        | 9342518 ->
          field_field0 := (
            Some (
              (
                Atdgen_runtime.Ob_run.read_int
              ) ib
            )
          );
        | 9342519 ->
          field_field1 := (
            Some (
              (
                Atdgen_runtime.Ob_run.read_float64
              ) ib
            )
          );
        | 9342520 ->
          field_field2 := (
            (
              read__6
            ) ib
          );
          bits0 := !bits0 lor 0x1;
        | 9342521 ->
          field_field3 := (
            (
              Atdgen_runtime.Ob_run.read_int64
            ) ib
          );
          bits0 := !bits0 lor 0x2;
        | 9342522 ->
          field_field4 := (
            (
              read__7
            ) ib
          );
          bits0 := !bits0 lor 0x4;
        | 9342523 ->
          field_field5 := (
            Some (
              (
                Atdgen_runtime.Ob_run.read_bool
              ) ib
            )
          );
        | 9342524 ->
          field_field6 := (
            Some (
              (
                Atdgen_runtime.Ob_run.read_string
              ) ib
            )
          );
        | 9342525 ->
          field_field7 := (
            (
              read_test_variant
            ) ib
          );
          bits0 := !bits0 lor 0x8;
        | 9342526 ->
          field_field8 := (
            (
              read__9
            ) ib
          );
          bits0 := !bits0 lor 0x10;
        | 9342527 ->
          field_field9 := (
            (
              fun ib ->
                if Bi_io.read_tag ib <> 20 then Atdgen_runtime.Ob_run.read_error_at ib;
                let len = Bi_vint.read_uvint ib in
                if len < 6 then Atdgen_runtime.Ob_run.missing_tuple_fields len [ 0; 1; 2; 3; 4; 5 ];
                let x0 =
                  (
                    Atdgen_runtime.Ob_run.read_int
                  ) ib
                in
                let x1 =
                  (
                    Atdgen_runtime.Ob_run.read_int
                  ) ib
                in
                let x2 =
                  (
                    Atdgen_runtime.Ob_run.read_char
                  ) ib
                in
                let x3 =
                  (
                    Atdgen_runtime.Ob_run.read_int
                  ) ib
                in
                let x4 =
                  (
                    Atdgen_runtime.Ob_run.read_int32
                  ) ib
                in
                let x5 =
                  (
                    Atdgen_runtime.Ob_run.read_int64
                  ) ib
                in
                for i = 6 to len - 1 do Bi_io.skip ib done;
                (x0, x1, x2, x3, x4, x5)
            ) ib
          );
          bits0 := !bits0 lor 0x20;
        | -64101863 ->
          field_field10 := (
            (
              Atdgen_runtime.Ob_run.read_bool
            ) ib
          );
          bits0 := !bits0 lor 0x40;
        | -64101862 ->
          field_field11 := (
            (
              Atdgen_runtime.Ob_run.read_bool
            ) ib
          );
        | -64101861 ->
          field_field12 := (
            (
              read__10
            ) ib
          );
          bits0 := !bits0 lor 0x80;
        | -64101860 ->
          field_field13 := (
            (
              read__11
            ) ib
          );
          bits0 := !bits0 lor 0x100;
        | -64101859 ->
          field_field14 := (
            (
              read_date
            ) ib
          );
          bits0 := !bits0 lor 0x200;
        | _ -> Bi_io.skip ib
    done;
    if !bits0 <> 0x3ff then Atdgen_runtime.Ob_run.missing_fields [| !bits0 |] [| "field2"; "field3"; "field4"; "field7"; "field8"; "field9"; "field10"; "field12"; "field13"; "field14" |];
    (
      {
        field0 = !field_field0;
        field1 = !field_field1;
        field2 = !field_field2;
        field3 = !field_field3;
        field4 = !field_field4;
        field5 = !field_field5;
        field6 = !field_field6;
        field7 = !field_field7;
        field8 = !field_field8;
        field9 = !field_field9;
        field10 = !field_field10;
        field11 = !field_field11;
        field12 = !field_field12;
        field13 = !field_field13;
        field14 = !field_field14;
      }
     : mixed_record)
)
let mixed_record_of_string ?pos s =
  read_mixed_record (Bi_inbuf.from_string ?pos s)
let _13_tag = Bi_io.array_tag
let write_untagged__13 = (
  Atdgen_runtime.Ob_run.write_untagged_array
    mixed_record_tag
    (
      write_untagged_mixed_record
    )
)
let write__13 ob x =
  Bi_io.write_tag ob Bi_io.array_tag;
  write_untagged__13 ob x
let string_of__13 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__13 ob x;
  Bi_outbuf.contents ob
let get__13_reader = (
  Atdgen_runtime.Ob_run.get_array_reader (
    get_mixed_record_reader
  )
)
let read__13 = (
  Atdgen_runtime.Ob_run.read_array (
    get_mixed_record_reader
  )
)
let _13_of_string ?pos s =
  read__13 (Bi_inbuf.from_string ?pos s)
let _12_tag = Bi_io.table_tag
let write_untagged__12 = (
  fun ob x ->
    let len = Array.length x in
    Bi_vint.write_uvint ob len;
    if len > 0 then (
      Bi_vint.write_uvint ob 15;
      Bi_io.write_hashtag ob (9342518) true;
      Bi_io.write_tag ob _4_tag;
      Bi_io.write_hashtag ob (9342519) true;
      Bi_io.write_tag ob _5_tag;
      Bi_io.write_hashtag ob (9342520) true;
      Bi_io.write_tag ob _6_tag;
      Bi_io.write_hashtag ob (9342521) true;
      Bi_io.write_tag ob Bi_io.int64_tag;
      Bi_io.write_hashtag ob (9342522) true;
      Bi_io.write_tag ob _7_tag;
      Bi_io.write_hashtag ob (9342523) true;
      Bi_io.write_tag ob _8_tag;
      Bi_io.write_hashtag ob (9342524) true;
      Bi_io.write_tag ob _6_tag;
      Bi_io.write_hashtag ob (9342525) true;
      Bi_io.write_tag ob test_variant_tag;
      Bi_io.write_hashtag ob (9342526) true;
      Bi_io.write_tag ob _9_tag;
      Bi_io.write_hashtag ob (9342527) true;
      Bi_io.write_tag ob Bi_io.tuple_tag;
      Bi_io.write_hashtag ob (-64101863) true;
      Bi_io.write_tag ob Bi_io.bool_tag;
      Bi_io.write_hashtag ob (-64101862) true;
      Bi_io.write_tag ob Bi_io.bool_tag;
      Bi_io.write_hashtag ob (-64101861) true;
      Bi_io.write_tag ob _10_tag;
      Bi_io.write_hashtag ob (-64101860) true;
      Bi_io.write_tag ob _11_tag;
      Bi_io.write_hashtag ob (-64101859) true;
      Bi_io.write_tag ob date_tag;
      Atdgen_runtime.Ob_run.array_iter2 (fun ob x ->
        (
          write_untagged__4
        )
          ob x.field0;
        (
          write_untagged__5
        )
          ob x.field1;
        (
          write_untagged__6
        )
          ob x.field2;
        (
          Bi_io.write_untagged_int64
        )
          ob x.field3;
        (
          write_untagged__7
        )
          ob x.field4;
        (
          write_untagged__8
        )
          ob x.field5;
        (
          write_untagged__6
        )
          ob x.field6;
        (
          write_untagged_test_variant
        )
          ob x.field7;
        (
          write_untagged__9
        )
          ob x.field8;
        (
          fun ob x ->
            Bi_vint.write_uvint ob 6;
            (
              let x, _, _, _, _, _ = x in (
                Bi_io.write_uvint
              ) ob x
            );
            (
              let _, x, _, _, _, _ = x in (
                Bi_io.write_int8
              ) ob x
            );
            (
              let _, _, x, _, _, _ = x in (
                Bi_io.write_char
              ) ob x
            );
            (
              let _, _, _, x, _, _ = x in (
                Bi_io.write_int16
              ) ob x
            );
            (
              let _, _, _, _, x, _ = x in (
                Bi_io.write_int32
              ) ob x
            );
            (
              let _, _, _, _, _, x = x in (
                Bi_io.write_int64
              ) ob x
            );
        )
          ob x.field9;
        (
          Bi_io.write_untagged_bool
        )
          ob x.field10;
        (
          Bi_io.write_untagged_bool
        )
          ob x.field11;
        (
          write_untagged__10
        )
          ob x.field12;
        (
          write_untagged__11
        )
          ob x.field13;
        (
          write_untagged_date
        )
          ob x.field14;
      ) ob x;
    );
)
let write__12 ob x =
  Bi_io.write_tag ob Bi_io.table_tag;
  write_untagged__12 ob x
let string_of__12 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__12 ob x;
  Bi_outbuf.contents ob
let get__12_reader = (
  function
    | 25 -> 
      (fun ib ->
        let row_num = Bi_vint.read_uvint ib in
        if row_num = 0 then [| |]
        else
          let col_num = Bi_vint.read_uvint ib in
          let field_field0 = ref (None) in
          let field_field1 = ref (None) in
          let field_field2 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
          let field_field3 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
          let field_field4 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
          let field_field5 = ref (None) in
          let field_field6 = ref (None) in
          let field_field7 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
          let field_field8 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
          let field_field9 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
          let field_field10 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
          let field_field11 = ref (false) in
          let field_field12 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
          let field_field13 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
          let field_field14 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
          let bits0 = ref 0 in
          let readers =
            Atdgen_runtime.Ob_run.array_init2 col_num ib (
              fun col ib ->
                let h = Bi_io.read_field_hashtag ib in
                let tag = Bi_io.read_tag ib in
                match h with
                  | 9342518 ->
                    let read =
                      (
                        get__4_reader
                      )
                        tag
                    in
                    (fun ib -> field_field0 := read ib)
                  | 9342519 ->
                    let read =
                      (
                        get__5_reader
                      )
                        tag
                    in
                    (fun ib -> field_field1 := read ib)
                  | 9342520 ->
                    bits0 := !bits0 lor 0x1;
                    let read =
                      (
                        get__6_reader
                      )
                        tag
                    in
                    (fun ib -> field_field2 := read ib)
                  | 9342521 ->
                    bits0 := !bits0 lor 0x2;
                    let read =
                      (
                        Atdgen_runtime.Ob_run.get_int64_reader
                      )
                        tag
                    in
                    (fun ib -> field_field3 := read ib)
                  | 9342522 ->
                    bits0 := !bits0 lor 0x4;
                    let read =
                      (
                        get__7_reader
                      )
                        tag
                    in
                    (fun ib -> field_field4 := read ib)
                  | 9342523 ->
                    let read =
                      (
                        get__8_reader
                      )
                        tag
                    in
                    (fun ib -> field_field5 := read ib)
                  | 9342524 ->
                    let read =
                      (
                        get__6_reader
                      )
                        tag
                    in
                    (fun ib -> field_field6 := read ib)
                  | 9342525 ->
                    bits0 := !bits0 lor 0x8;
                    let read =
                      (
                        get_test_variant_reader
                      )
                        tag
                    in
                    (fun ib -> field_field7 := read ib)
                  | 9342526 ->
                    bits0 := !bits0 lor 0x10;
                    let read =
                      (
                        get__9_reader
                      )
                        tag
                    in
                    (fun ib -> field_field8 := read ib)
                  | 9342527 ->
                    bits0 := !bits0 lor 0x20;
                    let read =
                      (
                        fun tag ->
                          if tag <> 20 then Atdgen_runtime.Ob_run.read_error () else
                            fun ib ->
                              let len = Bi_vint.read_uvint ib in
                              if len < 6 then Atdgen_runtime.Ob_run.missing_tuple_fields len [ 0; 1; 2; 3; 4; 5 ];
                              let x0 =
                                (
                                  Atdgen_runtime.Ob_run.read_int
                                ) ib
                              in
                              let x1 =
                                (
                                  Atdgen_runtime.Ob_run.read_int
                                ) ib
                              in
                              let x2 =
                                (
                                  Atdgen_runtime.Ob_run.read_char
                                ) ib
                              in
                              let x3 =
                                (
                                  Atdgen_runtime.Ob_run.read_int
                                ) ib
                              in
                              let x4 =
                                (
                                  Atdgen_runtime.Ob_run.read_int32
                                ) ib
                              in
                              let x5 =
                                (
                                  Atdgen_runtime.Ob_run.read_int64
                                ) ib
                              in
                              for i = 6 to len - 1 do Bi_io.skip ib done;
                              (x0, x1, x2, x3, x4, x5)
                      )
                        tag
                    in
                    (fun ib -> field_field9 := read ib)
                  | -64101863 ->
                    bits0 := !bits0 lor 0x40;
                    let read =
                      (
                        Atdgen_runtime.Ob_run.get_bool_reader
                      )
                        tag
                    in
                    (fun ib -> field_field10 := read ib)
                  | -64101862 ->
                    let read =
                      (
                        Atdgen_runtime.Ob_run.get_bool_reader
                      )
                        tag
                    in
                    (fun ib -> field_field11 := read ib)
                  | -64101861 ->
                    bits0 := !bits0 lor 0x80;
                    let read =
                      (
                        get__10_reader
                      )
                        tag
                    in
                    (fun ib -> field_field12 := read ib)
                  | -64101860 ->
                    bits0 := !bits0 lor 0x100;
                    let read =
                      (
                        get__11_reader
                      )
                        tag
                    in
                    (fun ib -> field_field13 := read ib)
                  | -64101859 ->
                    bits0 := !bits0 lor 0x200;
                    let read =
                      (
                        get_date_reader
                      )
                        tag
                    in
                    (fun ib -> field_field14 := read ib)
                  | _ -> (fun ib -> Bi_io.skip ib)
            )
          in
          if !bits0 <> 0x3ff then Atdgen_runtime.Ob_run.missing_fields [| !bits0 |] [| "field2"; "field3"; "field4"; "field7"; "field8"; "field9"; "field10"; "field12"; "field13"; "field14" |];
          let a = Array.make row_num (Obj.magic 0) in
          for row = 0 to row_num - 1 do
            for i = 0 to Array.length readers - 1 do
              readers.(i) ib
            done;
            a.(row) <-
              {
                field0 = !field_field0;
                field1 = !field_field1;
                field2 = !field_field2;
                field3 = !field_field3;
                field4 = !field_field4;
                field5 = !field_field5;
                field6 = !field_field6;
                field7 = !field_field7;
                field8 = !field_field8;
                field9 = !field_field9;
                field10 = !field_field10;
                field11 = !field_field11;
                field12 = !field_field12;
                field13 = !field_field13;
                field14 = !field_field14;
              }
          done;
          a
      )
    | 19 -> 
      (fun ib ->
        Atdgen_runtime.Ob_run.read_array_value (
          get_mixed_record_reader
        ) ib
      )
    | _ -> Atdgen_runtime.Ob_run.read_error ()
)
let read__12 = (
  fun ib ->
    match Bi_io.read_tag ib with
      | 25 -> 
        let row_num = Bi_vint.read_uvint ib in
        if row_num = 0 then [| |]
        else
          let col_num = Bi_vint.read_uvint ib in
          let field_field0 = ref (None) in
          let field_field1 = ref (None) in
          let field_field2 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
          let field_field3 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
          let field_field4 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
          let field_field5 = ref (None) in
          let field_field6 = ref (None) in
          let field_field7 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
          let field_field8 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
          let field_field9 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
          let field_field10 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
          let field_field11 = ref (false) in
          let field_field12 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
          let field_field13 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
          let field_field14 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
          let bits0 = ref 0 in
          let readers =
            Atdgen_runtime.Ob_run.array_init2 col_num ib (
              fun col ib ->
                let h = Bi_io.read_field_hashtag ib in
                let tag = Bi_io.read_tag ib in
                match h with
                  | 9342518 ->
                    let read =
                      (
                        get__4_reader
                      )
                        tag
                    in
                    (fun ib -> field_field0 := read ib)
                  | 9342519 ->
                    let read =
                      (
                        get__5_reader
                      )
                        tag
                    in
                    (fun ib -> field_field1 := read ib)
                  | 9342520 ->
                    bits0 := !bits0 lor 0x1;
                    let read =
                      (
                        get__6_reader
                      )
                        tag
                    in
                    (fun ib -> field_field2 := read ib)
                  | 9342521 ->
                    bits0 := !bits0 lor 0x2;
                    let read =
                      (
                        Atdgen_runtime.Ob_run.get_int64_reader
                      )
                        tag
                    in
                    (fun ib -> field_field3 := read ib)
                  | 9342522 ->
                    bits0 := !bits0 lor 0x4;
                    let read =
                      (
                        get__7_reader
                      )
                        tag
                    in
                    (fun ib -> field_field4 := read ib)
                  | 9342523 ->
                    let read =
                      (
                        get__8_reader
                      )
                        tag
                    in
                    (fun ib -> field_field5 := read ib)
                  | 9342524 ->
                    let read =
                      (
                        get__6_reader
                      )
                        tag
                    in
                    (fun ib -> field_field6 := read ib)
                  | 9342525 ->
                    bits0 := !bits0 lor 0x8;
                    let read =
                      (
                        get_test_variant_reader
                      )
                        tag
                    in
                    (fun ib -> field_field7 := read ib)
                  | 9342526 ->
                    bits0 := !bits0 lor 0x10;
                    let read =
                      (
                        get__9_reader
                      )
                        tag
                    in
                    (fun ib -> field_field8 := read ib)
                  | 9342527 ->
                    bits0 := !bits0 lor 0x20;
                    let read =
                      (
                        fun tag ->
                          if tag <> 20 then Atdgen_runtime.Ob_run.read_error () else
                            fun ib ->
                              let len = Bi_vint.read_uvint ib in
                              if len < 6 then Atdgen_runtime.Ob_run.missing_tuple_fields len [ 0; 1; 2; 3; 4; 5 ];
                              let x0 =
                                (
                                  Atdgen_runtime.Ob_run.read_int
                                ) ib
                              in
                              let x1 =
                                (
                                  Atdgen_runtime.Ob_run.read_int
                                ) ib
                              in
                              let x2 =
                                (
                                  Atdgen_runtime.Ob_run.read_char
                                ) ib
                              in
                              let x3 =
                                (
                                  Atdgen_runtime.Ob_run.read_int
                                ) ib
                              in
                              let x4 =
                                (
                                  Atdgen_runtime.Ob_run.read_int32
                                ) ib
                              in
                              let x5 =
                                (
                                  Atdgen_runtime.Ob_run.read_int64
                                ) ib
                              in
                              for i = 6 to len - 1 do Bi_io.skip ib done;
                              (x0, x1, x2, x3, x4, x5)
                      )
                        tag
                    in
                    (fun ib -> field_field9 := read ib)
                  | -64101863 ->
                    bits0 := !bits0 lor 0x40;
                    let read =
                      (
                        Atdgen_runtime.Ob_run.get_bool_reader
                      )
                        tag
                    in
                    (fun ib -> field_field10 := read ib)
                  | -64101862 ->
                    let read =
                      (
                        Atdgen_runtime.Ob_run.get_bool_reader
                      )
                        tag
                    in
                    (fun ib -> field_field11 := read ib)
                  | -64101861 ->
                    bits0 := !bits0 lor 0x80;
                    let read =
                      (
                        get__10_reader
                      )
                        tag
                    in
                    (fun ib -> field_field12 := read ib)
                  | -64101860 ->
                    bits0 := !bits0 lor 0x100;
                    let read =
                      (
                        get__11_reader
                      )
                        tag
                    in
                    (fun ib -> field_field13 := read ib)
                  | -64101859 ->
                    bits0 := !bits0 lor 0x200;
                    let read =
                      (
                        get_date_reader
                      )
                        tag
                    in
                    (fun ib -> field_field14 := read ib)
                  | _ -> (fun ib -> Bi_io.skip ib)
            )
          in
          if !bits0 <> 0x3ff then Atdgen_runtime.Ob_run.missing_fields [| !bits0 |] [| "field2"; "field3"; "field4"; "field7"; "field8"; "field9"; "field10"; "field12"; "field13"; "field14" |];
          let a = Array.make row_num (Obj.magic 0) in
          for row = 0 to row_num - 1 do
            for i = 0 to Array.length readers - 1 do
              readers.(i) ib
            done;
            a.(row) <-
              {
                field0 = !field_field0;
                field1 = !field_field1;
                field2 = !field_field2;
                field3 = !field_field3;
                field4 = !field_field4;
                field5 = !field_field5;
                field6 = !field_field6;
                field7 = !field_field7;
                field8 = !field_field8;
                field9 = !field_field9;
                field10 = !field_field10;
                field11 = !field_field11;
                field12 = !field_field12;
                field13 = !field_field13;
                field14 = !field_field14;
              }
          done;
          a
      | 19 -> 
        Atdgen_runtime.Ob_run.read_array_value (
          get_mixed_record_reader
        ) ib
      | _ -> Atdgen_runtime.Ob_run.read_error_at ib
)
let _12_of_string ?pos s =
  read__12 (Bi_inbuf.from_string ?pos s)
let _14_tag = Bi_io.array_tag
let write_untagged__14 = (
  Atdgen_runtime.Ob_run.write_untagged_list
    Bi_io.tuple_tag
    (
      fun ob x ->
        Bi_vint.write_uvint ob 2;
        (
          let x, _ = x in (
            write__12
          ) ob x
        );
        (
          let _, x = x in (
            write__13
          ) ob x
        );
    )
)
let write__14 ob x =
  Bi_io.write_tag ob Bi_io.array_tag;
  write_untagged__14 ob x
let string_of__14 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__14 ob x;
  Bi_outbuf.contents ob
let get__14_reader = (
  Atdgen_runtime.Ob_run.get_list_reader (
    fun tag ->
      if tag <> 20 then Atdgen_runtime.Ob_run.read_error () else
        fun ib ->
          let len = Bi_vint.read_uvint ib in
          if len < 2 then Atdgen_runtime.Ob_run.missing_tuple_fields len [ 0; 1 ];
          let x0 =
            (
              read__12
            ) ib
          in
          let x1 =
            (
              read__13
            ) ib
          in
          for i = 2 to len - 1 do Bi_io.skip ib done;
          (x0, x1)
  )
)
let read__14 = (
  Atdgen_runtime.Ob_run.read_list (
    fun tag ->
      if tag <> 20 then Atdgen_runtime.Ob_run.read_error () else
        fun ib ->
          let len = Bi_vint.read_uvint ib in
          if len < 2 then Atdgen_runtime.Ob_run.missing_tuple_fields len [ 0; 1 ];
          let x0 =
            (
              read__12
            ) ib
          in
          let x1 =
            (
              read__13
            ) ib
          in
          for i = 2 to len - 1 do Bi_io.skip ib done;
          (x0, x1)
  )
)
let _14_of_string ?pos s =
  read__14 (Bi_inbuf.from_string ?pos s)
let mixed_tag = Bi_io.array_tag
let write_untagged_mixed = (
  write_untagged__14
)
let write_mixed ob x =
  Bi_io.write_tag ob Bi_io.array_tag;
  write_untagged_mixed ob x
let string_of_mixed ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_mixed ob x;
  Bi_outbuf.contents ob
let get_mixed_reader = (
  get__14_reader
)
let read_mixed = (
  read__14
)
let mixed_of_string ?pos s =
  read_mixed (Bi_inbuf.from_string ?pos s)
let _15_tag = Bi_io.array_tag
let write_untagged__15 = (
  Atdgen_runtime.Ob_run.write_untagged_list
    mixed_record_tag
    (
      write_untagged_mixed_record
    )
)
let write__15 ob x =
  Bi_io.write_tag ob Bi_io.array_tag;
  write_untagged__15 ob x
let string_of__15 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__15 ob x;
  Bi_outbuf.contents ob
let get__15_reader = (
  Atdgen_runtime.Ob_run.get_list_reader (
    get_mixed_record_reader
  )
)
let read__15 = (
  Atdgen_runtime.Ob_run.read_list (
    get_mixed_record_reader
  )
)
let _15_of_string ?pos s =
  read__15 (Bi_inbuf.from_string ?pos s)
let test_tag = Bi_io.record_tag
let write_untagged_test : Bi_outbuf.t -> test -> unit = (
  fun ob x ->
    let len = ref 3 in
    let x_x0 = x.x0 in
    if x_x0 != None then incr len;
    let x_x1 = x.x1 in
    if x_x1 != None then incr len;
    Bi_vint.write_uvint ob !len;
    (match x_x0 with None -> () | Some x ->
      Bi_outbuf.add_char4 ob '\128' '\000' 'h' '\184';
      (
        Bi_io.write_svint
      ) ob x;
    );
    (match x_x1 with None -> () | Some x ->
      Bi_outbuf.add_char4 ob '\128' '\000' 'h' '\185';
      (
        Bi_io.write_float64
      ) ob x;
    );
    Bi_outbuf.add_char4 ob '\128' '\000' 'h' '\186';
    (
      write_mixed
    ) ob x.x2;
    Bi_outbuf.add_char4 ob '\128' '\000' 'h' '\187';
    (
      write__15
    ) ob x.x3;
    Bi_outbuf.add_char4 ob '\128' '\000' 'h' '\188';
    (
      Bi_io.write_int64
    ) ob x.x4;
)
let write_test ob x =
  Bi_io.write_tag ob Bi_io.record_tag;
  write_untagged_test ob x
let string_of_test ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_test ob x;
  Bi_outbuf.contents ob
let get_test_reader = (
  fun tag ->
    if tag <> 21 then Atdgen_runtime.Ob_run.read_error () else
      fun ib ->
        let field_x0 = ref (None) in
        let field_x1 = ref (None) in
        let field_x2 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let field_x3 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let field_x4 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let bits0 = ref 0 in
        let len = Bi_vint.read_uvint ib in
        for i = 1 to len do
          match Bi_io.read_field_hashtag ib with
            | 26808 ->
              field_x0 := (
                Some (
                  (
                    Atdgen_runtime.Ob_run.read_int
                  ) ib
                )
              );
            | 26809 ->
              field_x1 := (
                Some (
                  (
                    Atdgen_runtime.Ob_run.read_float64
                  ) ib
                )
              );
            | 26810 ->
              field_x2 := (
                (
                  read_mixed
                ) ib
              );
              bits0 := !bits0 lor 0x1;
            | 26811 ->
              field_x3 := (
                (
                  read__15
                ) ib
              );
              bits0 := !bits0 lor 0x2;
            | 26812 ->
              field_x4 := (
                (
                  Atdgen_runtime.Ob_run.read_int64
                ) ib
              );
              bits0 := !bits0 lor 0x4;
            | _ -> Bi_io.skip ib
        done;
        if !bits0 <> 0x7 then Atdgen_runtime.Ob_run.missing_fields [| !bits0 |] [| "x2"; "x3"; "x4" |];
        (
          {
            x0 = !field_x0;
            x1 = !field_x1;
            x2 = !field_x2;
            x3 = !field_x3;
            x4 = !field_x4;
          }
         : test)
)
let read_test = (
  fun ib ->
    if Bi_io.read_tag ib <> 21 then Atdgen_runtime.Ob_run.read_error_at ib;
    let field_x0 = ref (None) in
    let field_x1 = ref (None) in
    let field_x2 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let field_x3 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let field_x4 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let bits0 = ref 0 in
    let len = Bi_vint.read_uvint ib in
    for i = 1 to len do
      match Bi_io.read_field_hashtag ib with
        | 26808 ->
          field_x0 := (
            Some (
              (
                Atdgen_runtime.Ob_run.read_int
              ) ib
            )
          );
        | 26809 ->
          field_x1 := (
            Some (
              (
                Atdgen_runtime.Ob_run.read_float64
              ) ib
            )
          );
        | 26810 ->
          field_x2 := (
            (
              read_mixed
            ) ib
          );
          bits0 := !bits0 lor 0x1;
        | 26811 ->
          field_x3 := (
            (
              read__15
            ) ib
          );
          bits0 := !bits0 lor 0x2;
        | 26812 ->
          field_x4 := (
            (
              Atdgen_runtime.Ob_run.read_int64
            ) ib
          );
          bits0 := !bits0 lor 0x4;
        | _ -> Bi_io.skip ib
    done;
    if !bits0 <> 0x7 then Atdgen_runtime.Ob_run.missing_fields [| !bits0 |] [| "x2"; "x3"; "x4" |];
    (
      {
        x0 = !field_x0;
        x1 = !field_x1;
        x2 = !field_x2;
        x3 = !field_x3;
        x4 = !field_x4;
      }
     : test)
)
let test_of_string ?pos s =
  read_test (Bi_inbuf.from_string ?pos s)
let tup_tag = Bi_io.tuple_tag
let write_untagged_tup = (
  fun ob x ->
    Bi_vint.write_uvint ob 2;
    (
      let x, _ = x in (
        Bi_io.write_svint
      ) ob x
    );
    (
      let _, x = x in (
        write_test
      ) ob x
    );
)
let write_tup ob x =
  Bi_io.write_tag ob Bi_io.tuple_tag;
  write_untagged_tup ob x
let string_of_tup ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_tup ob x;
  Bi_outbuf.contents ob
let get_tup_reader = (
  fun tag ->
    if tag <> 20 then Atdgen_runtime.Ob_run.read_error () else
      fun ib ->
        let len = Bi_vint.read_uvint ib in
        if len < 2 then Atdgen_runtime.Ob_run.missing_tuple_fields len [ 0; 1 ];
        let x0 =
          (
            Atdgen_runtime.Ob_run.read_int
          ) ib
        in
        let x1 =
          (
            read_test
          ) ib
        in
        for i = 2 to len - 1 do Bi_io.skip ib done;
        (x0, x1)
)
let read_tup = (
  fun ib ->
    if Bi_io.read_tag ib <> 20 then Atdgen_runtime.Ob_run.read_error_at ib;
    let len = Bi_vint.read_uvint ib in
    if len < 2 then Atdgen_runtime.Ob_run.missing_tuple_fields len [ 0; 1 ];
    let x0 =
      (
        Atdgen_runtime.Ob_run.read_int
      ) ib
    in
    let x1 =
      (
        read_test
      ) ib
    in
    for i = 2 to len - 1 do Bi_io.skip ib done;
    (x0, x1)
)
let tup_of_string ?pos s =
  read_tup (Bi_inbuf.from_string ?pos s)
let star_rating_tag = Bi_io.svint_tag
let write_untagged_star_rating = (
  Bi_io.write_untagged_svint
)
let write_star_rating ob x =
  Bi_io.write_tag ob Bi_io.svint_tag;
  write_untagged_star_rating ob x
let string_of_star_rating ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_star_rating ob x;
  Bi_outbuf.contents ob
let get_star_rating_reader = (
  Atdgen_runtime.Ob_run.get_int_reader
)
let read_star_rating = (
  Atdgen_runtime.Ob_run.read_int
)
let star_rating_of_string ?pos s =
  read_star_rating (Bi_inbuf.from_string ?pos s)
let _30_tag = Bi_io.record_tag
let write_untagged__30 : Bi_outbuf.t -> _ generic -> unit = (
  fun ob x ->
    Bi_vint.write_uvint ob 1;
    Bi_outbuf.add_char4 ob '\240' 'G' '\003' '\130';
    (
      Bi_io.write_svint
    ) ob x.x294623;
)
let write__30 ob x =
  Bi_io.write_tag ob Bi_io.record_tag;
  write_untagged__30 ob x
let string_of__30 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__30 ob x;
  Bi_outbuf.contents ob
let get__30_reader = (
  fun tag ->
    if tag <> 21 then Atdgen_runtime.Ob_run.read_error () else
      fun ib ->
        let field_x294623 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let bits0 = ref 0 in
        let len = Bi_vint.read_uvint ib in
        for i = 1 to len do
          match Bi_io.read_field_hashtag ib with
            | -263781502 ->
              field_x294623 := (
                (
                  Atdgen_runtime.Ob_run.read_int
                ) ib
              );
              bits0 := !bits0 lor 0x1;
            | _ -> Bi_io.skip ib
        done;
        if !bits0 <> 0x1 then Atdgen_runtime.Ob_run.missing_fields [| !bits0 |] [| "x294623" |];
        (
          {
            x294623 = !field_x294623;
          }
         : _ generic)
)
let read__30 = (
  fun ib ->
    if Bi_io.read_tag ib <> 21 then Atdgen_runtime.Ob_run.read_error_at ib;
    let field_x294623 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let bits0 = ref 0 in
    let len = Bi_vint.read_uvint ib in
    for i = 1 to len do
      match Bi_io.read_field_hashtag ib with
        | -263781502 ->
          field_x294623 := (
            (
              Atdgen_runtime.Ob_run.read_int
            ) ib
          );
          bits0 := !bits0 lor 0x1;
        | _ -> Bi_io.skip ib
    done;
    if !bits0 <> 0x1 then Atdgen_runtime.Ob_run.missing_fields [| !bits0 |] [| "x294623" |];
    (
      {
        x294623 = !field_x294623;
      }
     : _ generic)
)
let _30_of_string ?pos s =
  read__30 (Bi_inbuf.from_string ?pos s)
let specialized_tag = Bi_io.record_tag
let write_untagged_specialized = (
  write_untagged__30
)
let write_specialized ob x =
  Bi_io.write_tag ob Bi_io.record_tag;
  write_untagged_specialized ob x
let string_of_specialized ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_specialized ob x;
  Bi_outbuf.contents ob
let get_specialized_reader = (
  get__30_reader
)
let read_specialized = (
  read__30
)
let specialized_of_string ?pos s =
  read_specialized (Bi_inbuf.from_string ?pos s)
let some_record_tag = Bi_io.record_tag
let write_untagged_some_record : Bi_outbuf.t -> some_record -> unit = (
  fun ob x ->
    Bi_vint.write_uvint ob 1;
    Bi_outbuf.add_char4 ob '\151' '\r' '\173' '\239';
    (
      Bi_io.write_svint
    ) ob x.some_field;
)
let write_some_record ob x =
  Bi_io.write_tag ob Bi_io.record_tag;
  write_untagged_some_record ob x
let string_of_some_record ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_some_record ob x;
  Bi_outbuf.contents ob
let get_some_record_reader = (
  fun tag ->
    if tag <> 21 then Atdgen_runtime.Ob_run.read_error () else
      fun ib ->
        let field_some_field = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let bits0 = ref 0 in
        let len = Bi_vint.read_uvint ib in
        for i = 1 to len do
          match Bi_io.read_field_hashtag ib with
            | 386772463 ->
              field_some_field := (
                (
                  Atdgen_runtime.Ob_run.read_int
                ) ib
              );
              bits0 := !bits0 lor 0x1;
            | _ -> Bi_io.skip ib
        done;
        if !bits0 <> 0x1 then Atdgen_runtime.Ob_run.missing_fields [| !bits0 |] [| "some_field" |];
        (
          {
            some_field = !field_some_field;
          }
         : some_record)
)
let read_some_record = (
  fun ib ->
    if Bi_io.read_tag ib <> 21 then Atdgen_runtime.Ob_run.read_error_at ib;
    let field_some_field = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let bits0 = ref 0 in
    let len = Bi_vint.read_uvint ib in
    for i = 1 to len do
      match Bi_io.read_field_hashtag ib with
        | 386772463 ->
          field_some_field := (
            (
              Atdgen_runtime.Ob_run.read_int
            ) ib
          );
          bits0 := !bits0 lor 0x1;
        | _ -> Bi_io.skip ib
    done;
    if !bits0 <> 0x1 then Atdgen_runtime.Ob_run.missing_fields [| !bits0 |] [| "some_field" |];
    (
      {
        some_field = !field_some_field;
      }
     : some_record)
)
let some_record_of_string ?pos s =
  read_some_record (Bi_inbuf.from_string ?pos s)
let precision_tag = Bi_io.record_tag
let write_untagged_precision : Bi_outbuf.t -> precision -> unit = (
  fun ob x ->
    Bi_vint.write_uvint ob 3;
    Bi_outbuf.add_char4 ob '\204' '\249' 'C' '\200';
    (
      Bi_io.write_float64
    ) ob x.sqrt2_5;
    Bi_outbuf.add_char4 ob '\228' '\158' 'C' 'z';
    (
      Bi_io.write_float64
    ) ob x.small_2;
    Bi_outbuf.add_char4 ob '\187' '\188' '+' 'n';
    (
      Bi_io.write_float64
    ) ob x.large_2;
)
let write_precision ob x =
  Bi_io.write_tag ob Bi_io.record_tag;
  write_untagged_precision ob x
let string_of_precision ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_precision ob x;
  Bi_outbuf.contents ob
let get_precision_reader = (
  fun tag ->
    if tag <> 21 then Atdgen_runtime.Ob_run.read_error () else
      fun ib ->
        let field_sqrt2_5 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let field_small_2 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let field_large_2 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let bits0 = ref 0 in
        let len = Bi_vint.read_uvint ib in
        for i = 1 to len do
          match Bi_io.read_field_hashtag ib with
            | -856079416 ->
              field_sqrt2_5 := (
                (
                  Atdgen_runtime.Ob_run.read_float64
                ) ib
              );
              bits0 := !bits0 lor 0x1;
            | -459390086 ->
              field_small_2 := (
                (
                  Atdgen_runtime.Ob_run.read_float64
                ) ib
              );
              bits0 := !bits0 lor 0x2;
            | 1002187630 ->
              field_large_2 := (
                (
                  Atdgen_runtime.Ob_run.read_float64
                ) ib
              );
              bits0 := !bits0 lor 0x4;
            | _ -> Bi_io.skip ib
        done;
        if !bits0 <> 0x7 then Atdgen_runtime.Ob_run.missing_fields [| !bits0 |] [| "sqrt2_5"; "small_2"; "large_2" |];
        (
          {
            sqrt2_5 = !field_sqrt2_5;
            small_2 = !field_small_2;
            large_2 = !field_large_2;
          }
         : precision)
)
let read_precision = (
  fun ib ->
    if Bi_io.read_tag ib <> 21 then Atdgen_runtime.Ob_run.read_error_at ib;
    let field_sqrt2_5 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let field_small_2 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let field_large_2 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let bits0 = ref 0 in
    let len = Bi_vint.read_uvint ib in
    for i = 1 to len do
      match Bi_io.read_field_hashtag ib with
        | -856079416 ->
          field_sqrt2_5 := (
            (
              Atdgen_runtime.Ob_run.read_float64
            ) ib
          );
          bits0 := !bits0 lor 0x1;
        | -459390086 ->
          field_small_2 := (
            (
              Atdgen_runtime.Ob_run.read_float64
            ) ib
          );
          bits0 := !bits0 lor 0x2;
        | 1002187630 ->
          field_large_2 := (
            (
              Atdgen_runtime.Ob_run.read_float64
            ) ib
          );
          bits0 := !bits0 lor 0x4;
        | _ -> Bi_io.skip ib
    done;
    if !bits0 <> 0x7 then Atdgen_runtime.Ob_run.missing_fields [| !bits0 |] [| "sqrt2_5"; "small_2"; "large_2" |];
    (
      {
        sqrt2_5 = !field_sqrt2_5;
        small_2 = !field_small_2;
        large_2 = !field_large_2;
      }
     : precision)
)
let precision_of_string ?pos s =
  read_precision (Bi_inbuf.from_string ?pos s)
let p''_tag = Bi_io.variant_tag
let write_untagged_p'' = (
  write_untagged__1
)
let write_p'' ob x =
  Bi_io.write_tag ob Bi_io.variant_tag;
  write_untagged_p'' ob x
let string_of_p'' ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_p'' ob x;
  Bi_outbuf.contents ob
let get_p''_reader = (
  get__1_reader
)
let read_p'' = (
  read__1
)
let p''_of_string ?pos s =
  read_p'' (Bi_inbuf.from_string ?pos s)
let _18_tag = Bi_io.num_variant_tag
let write_untagged__18 = (
  Atdgen_runtime.Ob_run.write_untagged_option (
    Bi_io.write_svint
  )
)
let write__18 ob x =
  Bi_io.write_tag ob Bi_io.num_variant_tag;
  write_untagged__18 ob x
let string_of__18 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__18 ob x;
  Bi_outbuf.contents ob
let get__18_reader = (
  fun tag ->
    if tag <> 22 then Atdgen_runtime.Ob_run.read_error () else
      fun ib ->
        match Char.code (Bi_inbuf.read_char ib) with
          | 0 -> None
          | 0x80 ->
            Some (
              (
                Atdgen_runtime.Ob_run.read_int
              )
                ib
            )
          | _ -> Atdgen_runtime.Ob_run.read_error_at ib
)
let read__18 = (
  fun ib ->
    if Bi_io.read_tag ib <> 22 then Atdgen_runtime.Ob_run.read_error_at ib;
    match Char.code (Bi_inbuf.read_char ib) with
      | 0 -> None
      | 0x80 ->
        Some (
          (
            Atdgen_runtime.Ob_run.read_int
          )
            ib
        )
      | _ -> Atdgen_runtime.Ob_run.read_error_at ib
)
let _18_of_string ?pos s =
  read__18 (Bi_inbuf.from_string ?pos s)
let option_validation_tag = Bi_io.num_variant_tag
let write_untagged_option_validation = (
  write_untagged__18
)
let write_option_validation ob x =
  Bi_io.write_tag ob Bi_io.num_variant_tag;
  write_untagged_option_validation ob x
let string_of_option_validation ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_option_validation ob x;
  Bi_outbuf.contents ob
let get_option_validation_reader = (
  get__18_reader
)
let read_option_validation = (
  read__18
)
let option_validation_of_string ?pos s =
  read_option_validation (Bi_inbuf.from_string ?pos s)
let _28_tag = some_record_tag
let write_untagged__28 = (
  write_untagged_some_record
)
let write__28 ob x =
  Bi_io.write_tag ob some_record_tag;
  write_untagged__28 ob x
let string_of__28 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__28 ob x;
  Bi_outbuf.contents ob
let get__28_reader = (
  get_some_record_reader
)
let read__28 = (
  read_some_record
)
let _28_of_string ?pos s =
  read__28 (Bi_inbuf.from_string ?pos s)
let no_real_wrap_tag = some_record_tag
let write_untagged_no_real_wrap = (
  write_untagged__28
)
let write_no_real_wrap ob x =
  Bi_io.write_tag ob some_record_tag;
  write_untagged_no_real_wrap ob x
let string_of_no_real_wrap ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_no_real_wrap ob x;
  Bi_outbuf.contents ob
let get_no_real_wrap_reader = (
  get__28_reader
)
let read_no_real_wrap = (
  read__28
)
let no_real_wrap_of_string ?pos s =
  read_no_real_wrap (Bi_inbuf.from_string ?pos s)
let _26_tag = Bi_io.svint_tag
let write_untagged__26 = (
  fun ob x -> (
    let x = ( Test_lib.Natural.unwrap ) x in (
      Bi_io.write_untagged_svint
    ) ob x)
)
let write__26 ob x =
  Bi_io.write_tag ob Bi_io.svint_tag;
  write_untagged__26 ob x
let string_of__26 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__26 ob x;
  Bi_outbuf.contents ob
let get__26_reader = (
  fun tag ib ->
    ( Test_lib.Natural.wrap ) ((
      Atdgen_runtime.Ob_run.get_int_reader
    ) tag ib)
)
let read__26 = (
  fun ib ->
    ( Test_lib.Natural.wrap ) ((
      Atdgen_runtime.Ob_run.read_int
    ) ib)
)
let _26_of_string ?pos s =
  read__26 (Bi_inbuf.from_string ?pos s)
let natural_tag = Bi_io.svint_tag
let write_untagged_natural = (
  write_untagged__26
)
let write_natural ob x =
  Bi_io.write_tag ob Bi_io.svint_tag;
  write_untagged_natural ob x
let string_of_natural ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_natural ob x;
  Bi_outbuf.contents ob
let get_natural_reader = (
  get__26_reader
)
let read_natural = (
  read__26
)
let natural_of_string ?pos s =
  read_natural (Bi_inbuf.from_string ?pos s)
let _24_tag = Bi_io.string_tag
let write_untagged__24 = (
  fun ob x -> (
    let x = ( function `Id s -> s ) x in (
      Bi_io.write_untagged_string
    ) ob x)
)
let write__24 ob x =
  Bi_io.write_tag ob Bi_io.string_tag;
  write_untagged__24 ob x
let string_of__24 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__24 ob x;
  Bi_outbuf.contents ob
let get__24_reader = (
  fun tag ib ->
    ( fun s -> `Id s ) ((
      Atdgen_runtime.Ob_run.get_string_reader
    ) tag ib)
)
let read__24 = (
  fun ib ->
    ( fun s -> `Id s ) ((
      Atdgen_runtime.Ob_run.read_string
    ) ib)
)
let _24_of_string ?pos s =
  read__24 (Bi_inbuf.from_string ?pos s)
let id_tag = Bi_io.string_tag
let write_untagged_id = (
  write_untagged__24
)
let write_id ob x =
  Bi_io.write_tag ob Bi_io.string_tag;
  write_untagged_id ob x
let string_of_id ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_id ob x;
  Bi_outbuf.contents ob
let get_id_reader = (
  get__24_reader
)
let read_id = (
  read__24
)
let id_of_string ?pos s =
  read_id (Bi_inbuf.from_string ?pos s)
let _25_tag = Bi_io.array_tag
let write_untagged__25 = (
  Atdgen_runtime.Ob_run.write_untagged_list
    Bi_io.tuple_tag
    (
      fun ob x ->
        Bi_vint.write_uvint ob 2;
        (
          let x, _ = x in (
            write_id
          ) ob x
        );
        (
          let _, x = x in (
            Bi_io.write_svint
          ) ob x
        );
    )
)
let write__25 ob x =
  Bi_io.write_tag ob Bi_io.array_tag;
  write_untagged__25 ob x
let string_of__25 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__25 ob x;
  Bi_outbuf.contents ob
let get__25_reader = (
  Atdgen_runtime.Ob_run.get_list_reader (
    fun tag ->
      if tag <> 20 then Atdgen_runtime.Ob_run.read_error () else
        fun ib ->
          let len = Bi_vint.read_uvint ib in
          if len < 2 then Atdgen_runtime.Ob_run.missing_tuple_fields len [ 0; 1 ];
          let x0 =
            (
              read_id
            ) ib
          in
          let x1 =
            (
              Atdgen_runtime.Ob_run.read_int
            ) ib
          in
          for i = 2 to len - 1 do Bi_io.skip ib done;
          (x0, x1)
  )
)
let read__25 = (
  Atdgen_runtime.Ob_run.read_list (
    fun tag ->
      if tag <> 20 then Atdgen_runtime.Ob_run.read_error () else
        fun ib ->
          let len = Bi_vint.read_uvint ib in
          if len < 2 then Atdgen_runtime.Ob_run.missing_tuple_fields len [ 0; 1 ];
          let x0 =
            (
              read_id
            ) ib
          in
          let x1 =
            (
              Atdgen_runtime.Ob_run.read_int
            ) ib
          in
          for i = 2 to len - 1 do Bi_io.skip ib done;
          (x0, x1)
  )
)
let _25_of_string ?pos s =
  read__25 (Bi_inbuf.from_string ?pos s)
let json_map_tag = Bi_io.array_tag
let write_untagged_json_map = (
  write_untagged__25
)
let write_json_map ob x =
  Bi_io.write_tag ob Bi_io.array_tag;
  write_untagged_json_map ob x
let string_of_json_map ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_json_map ob x;
  Bi_outbuf.contents ob
let get_json_map_reader = (
  get__25_reader
)
let read_json_map = (
  read__25
)
let json_map_of_string ?pos s =
  read_json_map (Bi_inbuf.from_string ?pos s)
let intopt_tag = Bi_io.num_variant_tag
let write_untagged_intopt = (
  write_untagged__4
)
let write_intopt ob x =
  Bi_io.write_tag ob Bi_io.num_variant_tag;
  write_untagged_intopt ob x
let string_of_intopt ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_intopt ob x;
  Bi_outbuf.contents ob
let get_intopt_reader = (
  get__4_reader
)
let read_intopt = (
  read__4
)
let intopt_of_string ?pos s =
  read_intopt (Bi_inbuf.from_string ?pos s)
let _21_tag = Bi_io.array_tag
let write_untagged__21 = (
  Atdgen_runtime.Ob_run.write_untagged_list
    Bi_io.tuple_tag
    (
      fun ob x ->
        Bi_vint.write_uvint ob 2;
        (
          let x, _ = x in (
            Bi_io.write_string
          ) ob x
        );
        (
          let _, x = x in (
            Bi_io.write_svint
          ) ob x
        );
    )
)
let write__21 ob x =
  Bi_io.write_tag ob Bi_io.array_tag;
  write_untagged__21 ob x
let string_of__21 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__21 ob x;
  Bi_outbuf.contents ob
let get__21_reader = (
  Atdgen_runtime.Ob_run.get_list_reader (
    fun tag ->
      if tag <> 20 then Atdgen_runtime.Ob_run.read_error () else
        fun ib ->
          let len = Bi_vint.read_uvint ib in
          if len < 2 then Atdgen_runtime.Ob_run.missing_tuple_fields len [ 0; 1 ];
          let x0 =
            (
              Atdgen_runtime.Ob_run.read_string
            ) ib
          in
          let x1 =
            (
              Atdgen_runtime.Ob_run.read_int
            ) ib
          in
          for i = 2 to len - 1 do Bi_io.skip ib done;
          (x0, x1)
  )
)
let read__21 = (
  Atdgen_runtime.Ob_run.read_list (
    fun tag ->
      if tag <> 20 then Atdgen_runtime.Ob_run.read_error () else
        fun ib ->
          let len = Bi_vint.read_uvint ib in
          if len < 2 then Atdgen_runtime.Ob_run.missing_tuple_fields len [ 0; 1 ];
          let x0 =
            (
              Atdgen_runtime.Ob_run.read_string
            ) ib
          in
          let x1 =
            (
              Atdgen_runtime.Ob_run.read_int
            ) ib
          in
          for i = 2 to len - 1 do Bi_io.skip ib done;
          (x0, x1)
  )
)
let _21_of_string ?pos s =
  read__21 (Bi_inbuf.from_string ?pos s)
let int_assoc_list_tag = Bi_io.array_tag
let write_untagged_int_assoc_list = (
  write_untagged__21
)
let write_int_assoc_list ob x =
  Bi_io.write_tag ob Bi_io.array_tag;
  write_untagged_int_assoc_list ob x
let string_of_int_assoc_list ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_int_assoc_list ob x;
  Bi_outbuf.contents ob
let get_int_assoc_list_reader = (
  get__21_reader
)
let read_int_assoc_list = (
  read__21
)
let int_assoc_list_of_string ?pos s =
  read_int_assoc_list (Bi_inbuf.from_string ?pos s)
let _22_tag = Bi_io.array_tag
let write_untagged__22 = (
  Atdgen_runtime.Ob_run.write_untagged_array
    Bi_io.tuple_tag
    (
      fun ob x ->
        Bi_vint.write_uvint ob 2;
        (
          let x, _ = x in (
            Bi_io.write_string
          ) ob x
        );
        (
          let _, x = x in (
            Bi_io.write_svint
          ) ob x
        );
    )
)
let write__22 ob x =
  Bi_io.write_tag ob Bi_io.array_tag;
  write_untagged__22 ob x
let string_of__22 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__22 ob x;
  Bi_outbuf.contents ob
let get__22_reader = (
  Atdgen_runtime.Ob_run.get_array_reader (
    fun tag ->
      if tag <> 20 then Atdgen_runtime.Ob_run.read_error () else
        fun ib ->
          let len = Bi_vint.read_uvint ib in
          if len < 2 then Atdgen_runtime.Ob_run.missing_tuple_fields len [ 0; 1 ];
          let x0 =
            (
              Atdgen_runtime.Ob_run.read_string
            ) ib
          in
          let x1 =
            (
              Atdgen_runtime.Ob_run.read_int
            ) ib
          in
          for i = 2 to len - 1 do Bi_io.skip ib done;
          (x0, x1)
  )
)
let read__22 = (
  Atdgen_runtime.Ob_run.read_array (
    fun tag ->
      if tag <> 20 then Atdgen_runtime.Ob_run.read_error () else
        fun ib ->
          let len = Bi_vint.read_uvint ib in
          if len < 2 then Atdgen_runtime.Ob_run.missing_tuple_fields len [ 0; 1 ];
          let x0 =
            (
              Atdgen_runtime.Ob_run.read_string
            ) ib
          in
          let x1 =
            (
              Atdgen_runtime.Ob_run.read_int
            ) ib
          in
          for i = 2 to len - 1 do Bi_io.skip ib done;
          (x0, x1)
  )
)
let _22_of_string ?pos s =
  read__22 (Bi_inbuf.from_string ?pos s)
let int_assoc_array_tag = Bi_io.array_tag
let write_untagged_int_assoc_array = (
  write_untagged__22
)
let write_int_assoc_array ob x =
  Bi_io.write_tag ob Bi_io.array_tag;
  write_untagged_int_assoc_array ob x
let string_of_int_assoc_array ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_int_assoc_array ob x;
  Bi_outbuf.contents ob
let get_int_assoc_array_reader = (
  get__22_reader
)
let read_int_assoc_array = (
  read__22
)
let int_assoc_array_of_string ?pos s =
  read_int_assoc_array (Bi_inbuf.from_string ?pos s)
let int8_tag = Bi_io.int8_tag
let write_untagged_int8 = (
  Bi_io.write_untagged_int8
)
let write_int8 ob x =
  Bi_io.write_tag ob Bi_io.int8_tag;
  write_untagged_int8 ob x
let string_of_int8 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_int8 ob x;
  Bi_outbuf.contents ob
let get_int8_reader = (
  Atdgen_runtime.Ob_run.get_int_reader
)
let read_int8 = (
  Atdgen_runtime.Ob_run.read_int
)
let int8_of_string ?pos s =
  read_int8 (Bi_inbuf.from_string ?pos s)
let int64_tag = Bi_io.int64_tag
let write_untagged_int64 = (
  Bi_io.write_untagged_int64
)
let write_int64 ob x =
  Bi_io.write_tag ob Bi_io.int64_tag;
  write_untagged_int64 ob x
let string_of_int64 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_int64 ob x;
  Bi_outbuf.contents ob
let get_int64_reader = (
  Atdgen_runtime.Ob_run.get_int64_reader
)
let read_int64 = (
  Atdgen_runtime.Ob_run.read_int64
)
let int64_of_string ?pos s =
  read_int64 (Bi_inbuf.from_string ?pos s)
let int32_tag = Bi_io.int32_tag
let write_untagged_int32 = (
  Bi_io.write_untagged_int32
)
let write_int32 ob x =
  Bi_io.write_tag ob Bi_io.int32_tag;
  write_untagged_int32 ob x
let string_of_int32 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_int32 ob x;
  Bi_outbuf.contents ob
let get_int32_reader = (
  Atdgen_runtime.Ob_run.get_int32_reader
)
let read_int32 = (
  Atdgen_runtime.Ob_run.read_int32
)
let int32_of_string ?pos s =
  read_int32 (Bi_inbuf.from_string ?pos s)
let hello_tag = Bi_io.variant_tag
let write_untagged_hello = (
  fun ob x ->
    match x with
      | `Hello x ->
        Bi_outbuf.add_char4 ob '\183' '\238' '\162' '\242';
        (
          Bi_io.write_string
        ) ob x
      | `World -> Bi_outbuf.add_char4 ob 'a' '\146' '\006' '2'
)
let write_hello ob x =
  Bi_io.write_tag ob Bi_io.variant_tag;
  write_untagged_hello ob x
let string_of_hello ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_hello ob x;
  Bi_outbuf.contents ob
let get_hello_reader = (
  fun tag ->
    if tag <> 23 then Atdgen_runtime.Ob_run.read_error () else
      fun ib ->
        Bi_io.read_hashtag ib (fun ib h has_arg ->
          match h, has_arg with
            | 938386162, true -> (`Hello (
                (
                  Atdgen_runtime.Ob_run.read_string
                ) ib
              ))
            | -510523854, false -> `World
            | _ -> Atdgen_runtime.Ob_run.unsupported_variant h has_arg
        )
)
let read_hello = (
  fun ib ->
    if Bi_io.read_tag ib <> 23 then Atdgen_runtime.Ob_run.read_error_at ib;
    Bi_io.read_hashtag ib (fun ib h has_arg ->
      match h, has_arg with
        | 938386162, true -> (`Hello (
            (
              Atdgen_runtime.Ob_run.read_string
            ) ib
          ))
        | -510523854, false -> `World
        | _ -> Atdgen_runtime.Ob_run.unsupported_variant h has_arg
    )
)
let hello_of_string ?pos s =
  read_hello (Bi_inbuf.from_string ?pos s)
let generic_tag = Bi_io.record_tag
let write_untagged_generic _a_tag write_untagged__a write__a : Bi_outbuf.t -> 'a generic -> unit = (
  fun ob x ->
    Bi_vint.write_uvint ob 1;
    Bi_outbuf.add_char4 ob '\240' 'G' '\003' '\130';
    (
      Bi_io.write_svint
    ) ob x.x294623;
)
let write_generic _a_tag write_untagged__a write__a ob x =
  Bi_io.write_tag ob Bi_io.record_tag;
  write_untagged_generic _a_tag write_untagged__a write__a ob x
let string_of_generic _a_tag write_untagged__a write__a ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_generic _a_tag write_untagged__a write__a ob x;
  Bi_outbuf.contents ob
let get_generic_reader get__a_reader read__a = (
  fun tag ->
    if tag <> 21 then Atdgen_runtime.Ob_run.read_error () else
      fun ib ->
        let field_x294623 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let bits0 = ref 0 in
        let len = Bi_vint.read_uvint ib in
        for i = 1 to len do
          match Bi_io.read_field_hashtag ib with
            | -263781502 ->
              field_x294623 := (
                (
                  Atdgen_runtime.Ob_run.read_int
                ) ib
              );
              bits0 := !bits0 lor 0x1;
            | _ -> Bi_io.skip ib
        done;
        if !bits0 <> 0x1 then Atdgen_runtime.Ob_run.missing_fields [| !bits0 |] [| "x294623" |];
        (
          {
            x294623 = !field_x294623;
          }
         : 'a generic)
)
let read_generic get__a_reader read__a = (
  fun ib ->
    if Bi_io.read_tag ib <> 21 then Atdgen_runtime.Ob_run.read_error_at ib;
    let field_x294623 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let bits0 = ref 0 in
    let len = Bi_vint.read_uvint ib in
    for i = 1 to len do
      match Bi_io.read_field_hashtag ib with
        | -263781502 ->
          field_x294623 := (
            (
              Atdgen_runtime.Ob_run.read_int
            ) ib
          );
          bits0 := !bits0 lor 0x1;
        | _ -> Bi_io.skip ib
    done;
    if !bits0 <> 0x1 then Atdgen_runtime.Ob_run.missing_fields [| !bits0 |] [| "x294623" |];
    (
      {
        x294623 = !field_x294623;
      }
     : 'a generic)
)
let generic_of_string get__a_reader read__a ?pos s =
  read_generic get__a_reader read__a (Bi_inbuf.from_string ?pos s)
let floats_tag = Bi_io.record_tag
let write_untagged_floats : Bi_outbuf.t -> floats -> unit = (
  fun ob x ->
    Bi_vint.write_uvint ob 2;
    Bi_outbuf.add_char4 ob '\128' 'M' '\146' '\133';
    (
      Bi_io.write_float32
    ) ob x.f32;
    Bi_outbuf.add_char4 ob '\128' 'M' '\149' '$';
    (
      Bi_io.write_float64
    ) ob x.f64;
)
let write_floats ob x =
  Bi_io.write_tag ob Bi_io.record_tag;
  write_untagged_floats ob x
let string_of_floats ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_floats ob x;
  Bi_outbuf.contents ob
let get_floats_reader = (
  fun tag ->
    if tag <> 21 then Atdgen_runtime.Ob_run.read_error () else
      fun ib ->
        let field_f32 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let field_f64 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let bits0 = ref 0 in
        let len = Bi_vint.read_uvint ib in
        for i = 1 to len do
          match Bi_io.read_field_hashtag ib with
            | 5083781 ->
              field_f32 := (
                (
                  Atdgen_runtime.Ob_run.read_float32
                ) ib
              );
              bits0 := !bits0 lor 0x1;
            | 5084452 ->
              field_f64 := (
                (
                  Atdgen_runtime.Ob_run.read_float64
                ) ib
              );
              bits0 := !bits0 lor 0x2;
            | _ -> Bi_io.skip ib
        done;
        if !bits0 <> 0x3 then Atdgen_runtime.Ob_run.missing_fields [| !bits0 |] [| "f32"; "f64" |];
        (
          {
            f32 = !field_f32;
            f64 = !field_f64;
          }
         : floats)
)
let read_floats = (
  fun ib ->
    if Bi_io.read_tag ib <> 21 then Atdgen_runtime.Ob_run.read_error_at ib;
    let field_f32 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let field_f64 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let bits0 = ref 0 in
    let len = Bi_vint.read_uvint ib in
    for i = 1 to len do
      match Bi_io.read_field_hashtag ib with
        | 5083781 ->
          field_f32 := (
            (
              Atdgen_runtime.Ob_run.read_float32
            ) ib
          );
          bits0 := !bits0 lor 0x1;
        | 5084452 ->
          field_f64 := (
            (
              Atdgen_runtime.Ob_run.read_float64
            ) ib
          );
          bits0 := !bits0 lor 0x2;
        | _ -> Bi_io.skip ib
    done;
    if !bits0 <> 0x3 then Atdgen_runtime.Ob_run.missing_fields [| !bits0 |] [| "f32"; "f64" |];
    (
      {
        f32 = !field_f32;
        f64 = !field_f64;
      }
     : floats)
)
let floats_of_string ?pos s =
  read_floats (Bi_inbuf.from_string ?pos s)
let _17_tag = Bi_io.array_tag
let write_untagged__17 = (
  Atdgen_runtime.Ob_run.write_untagged_list
    Bi_io.string_tag
    (
      Bi_io.write_untagged_string
    )
)
let write__17 ob x =
  Bi_io.write_tag ob Bi_io.array_tag;
  write_untagged__17 ob x
let string_of__17 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__17 ob x;
  Bi_outbuf.contents ob
let get__17_reader = (
  Atdgen_runtime.Ob_run.get_list_reader (
    Atdgen_runtime.Ob_run.get_string_reader
  )
)
let read__17 = (
  Atdgen_runtime.Ob_run.read_list (
    Atdgen_runtime.Ob_run.get_string_reader
  )
)
let _17_of_string ?pos s =
  read__17 (Bi_inbuf.from_string ?pos s)
let extended_tuple_tag = Bi_io.tuple_tag
let write_untagged_extended_tuple = (
  fun ob x ->
    Bi_vint.write_uvint ob 6;
    (
      let x, _, _, _, _, _ = x in (
        Bi_io.write_svint
      ) ob x
    );
    (
      let _, x, _, _, _, _ = x in (
        Bi_io.write_float64
      ) ob x
    );
    (
      let _, _, x, _, _, _ = x in (
        Bi_io.write_bool
      ) ob x
    );
    (
      let _, _, _, x, _, _ = x in (
        write__4
      ) ob x
    );
    (
      let _, _, _, _, x, _ = x in (
        Bi_io.write_string
      ) ob x
    );
    (
      let _, _, _, _, _, x = x in (
        write__17
      ) ob x
    );
)
let write_extended_tuple ob x =
  Bi_io.write_tag ob Bi_io.tuple_tag;
  write_untagged_extended_tuple ob x
let string_of_extended_tuple ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_extended_tuple ob x;
  Bi_outbuf.contents ob
let get_extended_tuple_reader = (
  fun tag ->
    if tag <> 20 then Atdgen_runtime.Ob_run.read_error () else
      fun ib ->
        let len = Bi_vint.read_uvint ib in
        if len < 5 then Atdgen_runtime.Ob_run.missing_tuple_fields len [ 0; 1; 4 ];
        let x0 =
          (
            Atdgen_runtime.Ob_run.read_int
          ) ib
        in
        let x1 =
          (
            Atdgen_runtime.Ob_run.read_float64
          ) ib
        in
        let x2 =
          (
            Atdgen_runtime.Ob_run.read_bool
          ) ib
        in
        let x3 =
          (
            read__4
          ) ib
        in
        let x4 =
          (
            Atdgen_runtime.Ob_run.read_string
          ) ib
        in
        let x5 =
          if len >= 6 then (
            read__17
          ) ib
          else
            []
        in
        for i = 6 to len - 1 do Bi_io.skip ib done;
        (x0, x1, x2, x3, x4, x5)
)
let read_extended_tuple = (
  fun ib ->
    if Bi_io.read_tag ib <> 20 then Atdgen_runtime.Ob_run.read_error_at ib;
    let len = Bi_vint.read_uvint ib in
    if len < 5 then Atdgen_runtime.Ob_run.missing_tuple_fields len [ 0; 1; 4 ];
    let x0 =
      (
        Atdgen_runtime.Ob_run.read_int
      ) ib
    in
    let x1 =
      (
        Atdgen_runtime.Ob_run.read_float64
      ) ib
    in
    let x2 =
      (
        Atdgen_runtime.Ob_run.read_bool
      ) ib
    in
    let x3 =
      (
        read__4
      ) ib
    in
    let x4 =
      (
        Atdgen_runtime.Ob_run.read_string
      ) ib
    in
    let x5 =
      if len >= 6 then (
        read__17
      ) ib
      else
        []
    in
    for i = 6 to len - 1 do Bi_io.skip ib done;
    (x0, x1, x2, x3, x4, x5)
)
let extended_tuple_of_string ?pos s =
  read_extended_tuple (Bi_inbuf.from_string ?pos s)
let extended_tag = Bi_io.record_tag
let write_untagged_extended : Bi_outbuf.t -> extended -> unit = (
  fun ob x ->
    let len = ref 4 in
    let x_b3x = x.b3x in
    if x_b3x != None then incr len;
    let x_b5x = x.b5x in
    if x_b5x != 0.5 then incr len;
    Bi_vint.write_uvint ob !len;
    Bi_outbuf.add_char4 ob '\128' '\000' 'U' '\142';
    (
      Bi_io.write_svint
    ) ob x.b0x;
    Bi_outbuf.add_char4 ob '\128' '\000' 'U' '\143';
    (
      Bi_io.write_bool
    ) ob x.b1x;
    Bi_outbuf.add_char4 ob '\128' '\000' 'U' '\144';
    (
      Bi_io.write_string
    ) ob x.b2x;
    (match x_b3x with None -> () | Some x ->
      Bi_outbuf.add_char4 ob '\128' '\000' 'U' '\145';
      (
        Bi_io.write_string
      ) ob x;
    );
    Bi_outbuf.add_char4 ob '\128' '\000' 'U' '\146';
    (
      write__6
    ) ob x.b4x;
    if x_b5x != 0.5 then (
      Bi_outbuf.add_char4 ob '\128' '\000' 'U' '\147';
      (
        Bi_io.write_float64
      ) ob x_b5x;
    );
)
let write_extended ob x =
  Bi_io.write_tag ob Bi_io.record_tag;
  write_untagged_extended ob x
let string_of_extended ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_extended ob x;
  Bi_outbuf.contents ob
let get_extended_reader = (
  fun tag ->
    if tag <> 21 then Atdgen_runtime.Ob_run.read_error () else
      fun ib ->
        let field_b0x = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let field_b1x = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let field_b2x = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let field_b3x = ref (None) in
        let field_b4x = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let field_b5x = ref (0.5) in
        let bits0 = ref 0 in
        let len = Bi_vint.read_uvint ib in
        for i = 1 to len do
          match Bi_io.read_field_hashtag ib with
            | 21902 ->
              field_b0x := (
                (
                  Atdgen_runtime.Ob_run.read_int
                ) ib
              );
              bits0 := !bits0 lor 0x1;
            | 21903 ->
              field_b1x := (
                (
                  Atdgen_runtime.Ob_run.read_bool
                ) ib
              );
              bits0 := !bits0 lor 0x2;
            | 21904 ->
              field_b2x := (
                (
                  Atdgen_runtime.Ob_run.read_string
                ) ib
              );
              bits0 := !bits0 lor 0x4;
            | 21905 ->
              field_b3x := (
                Some (
                  (
                    Atdgen_runtime.Ob_run.read_string
                  ) ib
                )
              );
            | 21906 ->
              field_b4x := (
                (
                  read__6
                ) ib
              );
              bits0 := !bits0 lor 0x8;
            | 21907 ->
              field_b5x := (
                (
                  Atdgen_runtime.Ob_run.read_float64
                ) ib
              );
            | _ -> Bi_io.skip ib
        done;
        if !bits0 <> 0xf then Atdgen_runtime.Ob_run.missing_fields [| !bits0 |] [| "b0"; "b1"; "b2"; "b4" |];
        (
          {
            b0x = !field_b0x;
            b1x = !field_b1x;
            b2x = !field_b2x;
            b3x = !field_b3x;
            b4x = !field_b4x;
            b5x = !field_b5x;
          }
         : extended)
)
let read_extended = (
  fun ib ->
    if Bi_io.read_tag ib <> 21 then Atdgen_runtime.Ob_run.read_error_at ib;
    let field_b0x = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let field_b1x = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let field_b2x = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let field_b3x = ref (None) in
    let field_b4x = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let field_b5x = ref (0.5) in
    let bits0 = ref 0 in
    let len = Bi_vint.read_uvint ib in
    for i = 1 to len do
      match Bi_io.read_field_hashtag ib with
        | 21902 ->
          field_b0x := (
            (
              Atdgen_runtime.Ob_run.read_int
            ) ib
          );
          bits0 := !bits0 lor 0x1;
        | 21903 ->
          field_b1x := (
            (
              Atdgen_runtime.Ob_run.read_bool
            ) ib
          );
          bits0 := !bits0 lor 0x2;
        | 21904 ->
          field_b2x := (
            (
              Atdgen_runtime.Ob_run.read_string
            ) ib
          );
          bits0 := !bits0 lor 0x4;
        | 21905 ->
          field_b3x := (
            Some (
              (
                Atdgen_runtime.Ob_run.read_string
              ) ib
            )
          );
        | 21906 ->
          field_b4x := (
            (
              read__6
            ) ib
          );
          bits0 := !bits0 lor 0x8;
        | 21907 ->
          field_b5x := (
            (
              Atdgen_runtime.Ob_run.read_float64
            ) ib
          );
        | _ -> Bi_io.skip ib
    done;
    if !bits0 <> 0xf then Atdgen_runtime.Ob_run.missing_fields [| !bits0 |] [| "b0"; "b1"; "b2"; "b4" |];
    (
      {
        b0x = !field_b0x;
        b1x = !field_b1x;
        b2x = !field_b2x;
        b3x = !field_b3x;
        b4x = !field_b4x;
        b5x = !field_b5x;
      }
     : extended)
)
let extended_of_string ?pos s =
  read_extended (Bi_inbuf.from_string ?pos s)
let _27_tag = natural_tag
let write_untagged__27 = (
  fun ob x -> (
    let x = ( Test_lib.Even_natural.unwrap ) x in (
      write_untagged_natural
    ) ob x)
)
let write__27 ob x =
  Bi_io.write_tag ob natural_tag;
  write_untagged__27 ob x
let string_of__27 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__27 ob x;
  Bi_outbuf.contents ob
let get__27_reader = (
  fun tag ib ->
    ( Test_lib.Even_natural.wrap ) ((
      get_natural_reader
    ) tag ib)
)
let read__27 = (
  fun ib ->
    ( Test_lib.Even_natural.wrap ) ((
      read_natural
    ) ib)
)
let _27_of_string ?pos s =
  read__27 (Bi_inbuf.from_string ?pos s)
let even_natural_tag = natural_tag
let write_untagged_even_natural = (
  write_untagged__27
)
let write_even_natural ob x =
  Bi_io.write_tag ob natural_tag;
  write_untagged_even_natural ob x
let string_of_even_natural ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_even_natural ob x;
  Bi_outbuf.contents ob
let get_even_natural_reader = (
  get__27_reader
)
let read_even_natural = (
  read__27
)
let even_natural_of_string ?pos s =
  read_even_natural (Bi_inbuf.from_string ?pos s)
let def_tag = Test_lib.Biniou.def_tag
let write_untagged_def = (
  Test_lib.Biniou.write_untagged_def
)
let write_def ob x =
  Bi_io.write_tag ob Test_lib.Biniou.def_tag;
  write_untagged_def ob x
let string_of_def ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_def ob x;
  Bi_outbuf.contents ob
let get_def_reader = (
  Test_lib.Biniou.get_def_reader
)
let read_def = (
  Test_lib.Biniou.read_def
)
let def_of_string ?pos s =
  read_def (Bi_inbuf.from_string ?pos s)
let char_tag = Bi_io.int8_tag
let write_untagged_char = (
  Bi_io.write_untagged_char
)
let write_char ob x =
  Bi_io.write_tag ob Bi_io.int8_tag;
  write_untagged_char ob x
let string_of_char ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_char ob x;
  Bi_outbuf.contents ob
let get_char_reader = (
  Atdgen_runtime.Ob_run.get_char_reader
)
let read_char = (
  Atdgen_runtime.Ob_run.read_char
)
let char_of_string ?pos s =
  read_char (Bi_inbuf.from_string ?pos s)
let base_tuple_tag = Bi_io.tuple_tag
let write_untagged_base_tuple = (
  fun ob x ->
    Bi_vint.write_uvint ob 2;
    (
      let x, _ = x in (
        Bi_io.write_svint
      ) ob x
    );
    (
      let _, x = x in (
        Bi_io.write_float64
      ) ob x
    );
)
let write_base_tuple ob x =
  Bi_io.write_tag ob Bi_io.tuple_tag;
  write_untagged_base_tuple ob x
let string_of_base_tuple ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_base_tuple ob x;
  Bi_outbuf.contents ob
let get_base_tuple_reader = (
  fun tag ->
    if tag <> 20 then Atdgen_runtime.Ob_run.read_error () else
      fun ib ->
        let len = Bi_vint.read_uvint ib in
        if len < 2 then Atdgen_runtime.Ob_run.missing_tuple_fields len [ 0; 1 ];
        let x0 =
          (
            Atdgen_runtime.Ob_run.read_int
          ) ib
        in
        let x1 =
          (
            Atdgen_runtime.Ob_run.read_float64
          ) ib
        in
        for i = 2 to len - 1 do Bi_io.skip ib done;
        (x0, x1)
)
let read_base_tuple = (
  fun ib ->
    if Bi_io.read_tag ib <> 20 then Atdgen_runtime.Ob_run.read_error_at ib;
    let len = Bi_vint.read_uvint ib in
    if len < 2 then Atdgen_runtime.Ob_run.missing_tuple_fields len [ 0; 1 ];
    let x0 =
      (
        Atdgen_runtime.Ob_run.read_int
      ) ib
    in
    let x1 =
      (
        Atdgen_runtime.Ob_run.read_float64
      ) ib
    in
    for i = 2 to len - 1 do Bi_io.skip ib done;
    (x0, x1)
)
let base_tuple_of_string ?pos s =
  read_base_tuple (Bi_inbuf.from_string ?pos s)
let base_tag = Bi_io.record_tag
let write_untagged_base : Bi_outbuf.t -> base -> unit = (
  fun ob x ->
    Bi_vint.write_uvint ob 2;
    Bi_outbuf.add_char4 ob '\128' '\000' 'U' '\142';
    (
      Bi_io.write_svint
    ) ob x.b0;
    Bi_outbuf.add_char4 ob '\128' '\000' 'U' '\143';
    (
      Bi_io.write_bool
    ) ob x.b1;
)
let write_base ob x =
  Bi_io.write_tag ob Bi_io.record_tag;
  write_untagged_base ob x
let string_of_base ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_base ob x;
  Bi_outbuf.contents ob
let get_base_reader = (
  fun tag ->
    if tag <> 21 then Atdgen_runtime.Ob_run.read_error () else
      fun ib ->
        let field_b0 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let field_b1 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let bits0 = ref 0 in
        let len = Bi_vint.read_uvint ib in
        for i = 1 to len do
          match Bi_io.read_field_hashtag ib with
            | 21902 ->
              field_b0 := (
                (
                  Atdgen_runtime.Ob_run.read_int
                ) ib
              );
              bits0 := !bits0 lor 0x1;
            | 21903 ->
              field_b1 := (
                (
                  Atdgen_runtime.Ob_run.read_bool
                ) ib
              );
              bits0 := !bits0 lor 0x2;
            | _ -> Bi_io.skip ib
        done;
        if !bits0 <> 0x3 then Atdgen_runtime.Ob_run.missing_fields [| !bits0 |] [| "b0"; "b1" |];
        (
          {
            b0 = !field_b0;
            b1 = !field_b1;
          }
         : base)
)
let read_base = (
  fun ib ->
    if Bi_io.read_tag ib <> 21 then Atdgen_runtime.Ob_run.read_error_at ib;
    let field_b0 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let field_b1 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let bits0 = ref 0 in
    let len = Bi_vint.read_uvint ib in
    for i = 1 to len do
      match Bi_io.read_field_hashtag ib with
        | 21902 ->
          field_b0 := (
            (
              Atdgen_runtime.Ob_run.read_int
            ) ib
          );
          bits0 := !bits0 lor 0x1;
        | 21903 ->
          field_b1 := (
            (
              Atdgen_runtime.Ob_run.read_bool
            ) ib
          );
          bits0 := !bits0 lor 0x2;
        | _ -> Bi_io.skip ib
    done;
    if !bits0 <> 0x3 then Atdgen_runtime.Ob_run.missing_fields [| !bits0 |] [| "b0"; "b1" |];
    (
      {
        b0 = !field_b0;
        b1 = !field_b1;
      }
     : base)
)
let base_of_string ?pos s =
  read_base (Bi_inbuf.from_string ?pos s)
let _23_tag = Bi_io.array_tag
let write_untagged__23 _a_tag write_untagged__a write__a = (
  Atdgen_runtime.Ob_run.write_untagged_array
    _a_tag
    (
      write_untagged__a
    )
)
let write__23 _a_tag write_untagged__a write__a ob x =
  Bi_io.write_tag ob Bi_io.array_tag;
  write_untagged__23 _a_tag write_untagged__a write__a ob x
let string_of__23 _a_tag write_untagged__a write__a ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__23 _a_tag write_untagged__a write__a ob x;
  Bi_outbuf.contents ob
let get__23_reader get__a_reader read__a = (
  Atdgen_runtime.Ob_run.get_array_reader (
    get__a_reader
  )
)
let read__23 get__a_reader read__a = (
  Atdgen_runtime.Ob_run.read_array (
    get__a_reader
  )
)
let _23_of_string get__a_reader read__a ?pos s =
  read__23 get__a_reader read__a (Bi_inbuf.from_string ?pos s)
let array_tag = Bi_io.array_tag
let write_untagged_array _a_tag write_untagged__a write__a = (
  write_untagged__23 _a_tag write_untagged__a write__a
)
let write_array _a_tag write_untagged__a write__a ob x =
  Bi_io.write_tag ob Bi_io.array_tag;
  write_untagged_array _a_tag write_untagged__a write__a ob x
let string_of_array _a_tag write_untagged__a write__a ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_array _a_tag write_untagged__a write__a ob x;
  Bi_outbuf.contents ob
let get_array_reader get__a_reader read__a = (
  get__23_reader get__a_reader read__a
)
let read_array get__a_reader read__a = (
  read__23 get__a_reader read__a
)
let array_of_string get__a_reader read__a ?pos s =
  read_array get__a_reader read__a (Bi_inbuf.from_string ?pos s)
let abs3_tag = Bi_io.array_tag
let write_untagged_abs3 _a_tag write_untagged__a write__a = (
  write_untagged__19 _a_tag write_untagged__a write__a
)
let write_abs3 _a_tag write_untagged__a write__a ob x =
  Bi_io.write_tag ob Bi_io.array_tag;
  write_untagged_abs3 _a_tag write_untagged__a write__a ob x
let string_of_abs3 _a_tag write_untagged__a write__a ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_abs3 _a_tag write_untagged__a write__a ob x;
  Bi_outbuf.contents ob
let get_abs3_reader get__a_reader read__a = (
  get__19_reader get__a_reader read__a
)
let read_abs3 get__a_reader read__a = (
  read__19 get__a_reader read__a
)
let abs3_of_string get__a_reader read__a ?pos s =
  read_abs3 get__a_reader read__a (Bi_inbuf.from_string ?pos s)
let abs2_tag = Bi_io.array_tag
let write_untagged_abs2 _a_tag write_untagged__a write__a = (
  write_untagged__19 _a_tag write_untagged__a write__a
)
let write_abs2 _a_tag write_untagged__a write__a ob x =
  Bi_io.write_tag ob Bi_io.array_tag;
  write_untagged_abs2 _a_tag write_untagged__a write__a ob x
let string_of_abs2 _a_tag write_untagged__a write__a ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_abs2 _a_tag write_untagged__a write__a ob x;
  Bi_outbuf.contents ob
let get_abs2_reader get__a_reader read__a = (
  get__19_reader get__a_reader read__a
)
let read_abs2 get__a_reader read__a = (
  read__19 get__a_reader read__a
)
let abs2_of_string get__a_reader read__a ?pos s =
  read_abs2 get__a_reader read__a (Bi_inbuf.from_string ?pos s)
let abs1_tag = Bi_io.array_tag
let write_untagged_abs1 _a_tag write_untagged__a write__a = (
  write_untagged__19 _a_tag write_untagged__a write__a
)
let write_abs1 _a_tag write_untagged__a write__a ob x =
  Bi_io.write_tag ob Bi_io.array_tag;
  write_untagged_abs1 _a_tag write_untagged__a write__a ob x
let string_of_abs1 _a_tag write_untagged__a write__a ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_abs1 _a_tag write_untagged__a write__a ob x;
  Bi_outbuf.contents ob
let get_abs1_reader get__a_reader read__a = (
  get__19_reader get__a_reader read__a
)
let read_abs1 get__a_reader read__a = (
  read__19 get__a_reader read__a
)
let abs1_of_string get__a_reader read__a ?pos s =
  read_abs1 get__a_reader read__a (Bi_inbuf.from_string ?pos s)
let create_r 
  ~a
  ~b
  ~c
  () : r =
  {
    a = a;
    b = b;
    c = c;
  }
let create_poly 
  ~fst
  ~snd
  () : ('x, 'y) poly =
  {
    fst = fst;
    snd = snd;
  }
let create_val1 
  ~val1_x
  () : val1 =
  {
    val1_x = val1_x;
  }
let create_val2 
  ~val2_x
  ?val2_y
  () : val2 =
  {
    val2_x = val2_x;
    val2_y = val2_y;
  }
let create_mixed_record 
  ?field0
  ?field1
  ~field2
  ~field3
  ~field4
  ?field5
  ?field6
  ~field7
  ~field8
  ~field9
  ~field10
  ?(field11 = false)
  ~field12
  ~field13
  ~field14
  () : mixed_record =
  {
    field0 = field0;
    field1 = field1;
    field2 = field2;
    field3 = field3;
    field4 = field4;
    field5 = field5;
    field6 = field6;
    field7 = field7;
    field8 = field8;
    field9 = field9;
    field10 = field10;
    field11 = field11;
    field12 = field12;
    field13 = field13;
    field14 = field14;
  }
let create_test 
  ?x0
  ?x1
  ~x2
  ~x3
  ~x4
  () : test =
  {
    x0 = x0;
    x1 = x1;
    x2 = x2;
    x3 = x3;
    x4 = x4;
  }
let create_some_record 
  ~some_field
  () : some_record =
  {
    some_field = some_field;
  }
let create_precision 
  ~sqrt2_5
  ~small_2
  ~large_2
  () : precision =
  {
    sqrt2_5 = sqrt2_5;
    small_2 = small_2;
    large_2 = large_2;
  }
let create_generic 
  ~x294623
  () : 'a generic =
  {
    x294623 = x294623;
  }
let create_floats 
  ~f32
  ~f64
  () : floats =
  {
    f32 = f32;
    f64 = f64;
  }
let create_extended 
  ~b0x
  ~b1x
  ~b2x
  ?b3x
  ~b4x
  ?(b5x = 0.5)
  () : extended =
  {
    b0x = b0x;
    b1x = b1x;
    b2x = b2x;
    b3x = b3x;
    b4x = b4x;
    b5x = b5x;
  }
let create_base 
  ~b0
  ~b1
  () : base =
  {
    b0 = b0;
    b1 = b1;
  }
atd-2.1.0/atdgen/test/test.expected.mli000066400000000000000000001535671357165332000200130ustar00rootroot00000000000000(* Auto-generated from "test.atd" *)
              [@@@ocaml.warning "-27-32-35-39"]

(** This is just a test. *)

type test_variant = [
    `Case1
  | `Case2 of int
  | `Case3 of string
  | `Case4 of test_variant list
]

type ('x, 'y) poly = { fst: 'x list; snd: ('x, 'y) poly option }

type 'a p' =  A | Bb of 'a p' | Ccccc of 'a 

type p = [ `A | `B of r | `C ]

and r = { a: int; mutable b: bool; c: p }

type validated_string_check = string

type validate_me = string list

type val1 = { val1_x: int }

type val2 = { val2_x: val1; val2_y: val1 option }

type unixtime_list = float list

type date = (int * int option * int option)

type mixed_record = {
  field0: int option;
  field1: float option;
  field2: string option;
  field3: Int64.t;
  field4: float Atdgen_runtime.Util.ocaml_array;
  field5: bool option;
  field6: string option;
  field7: test_variant;
  field8: string Atdgen_runtime.Util.ocaml_array;
  field9: (int * int * Char.t * int * Int32.t * Int64.t);
  field10: bool;
  field11: bool;
  field12: unit list;
  field13: string option list;
  field14: date
}

type mixed =
  (
      mixed_record Atdgen_runtime.Util.ocaml_array
    * mixed_record Atdgen_runtime.Util.ocaml_array
  ) list

type test = {
  x0: int option;
  x1: float option;
  x2: mixed;
  x3: mixed_record list;
  x4: Int64.t
}

type tup = (int * test)

type star_rating = int

type 'a generic = { x294623: int }

type specialized = string generic

type some_record = { some_field: int }

type precision = { sqrt2_5: float; small_2: float; large_2: float }

type p'' = int p'

type option_validation = int option

type no_real_wrap = some_record

type natural = Test_lib.Natural.t

type id = [ `Id of string ]

type json_map = (id * int) list

type intopt = int option

type int_assoc_list = (string * int) list

type int_assoc_array = (string * int) Atdgen_runtime.Util.ocaml_array

type int8 = int

type int64 = Int64.t

type int32 = Int32.t

type hello = [ `Hello of string | `World ]

type floats = { f32: float; f64: float }

type extended_tuple = (
    int
  * float
  * bool
  * int option
  * string
  * string list
)

type extended = {
  b0x (*atd b0 *): int;
  b1x (*atd b1 *): bool;
  b2x (*atd b2 *): string;
  b3x (*atd b3 *): string option;
  b4x (*atd b4 *): string option;
  b5x (*atd b5 *): float
}

type even_natural = Test_lib.Even_natural.t

(**
  \}\}\}abc[def]ghi
  
{v
j  *  j
 k * k
  l*l
v}
  
{v
mno
v}
  
  [pqr]\{stu\}vwx
  
  yz
  
  [\} \[ \] \{v]
  
{v
\} [x] v\} \{v [ @ 
v}
*)
type def = Test_lib.Biniou.def

type char = Char.t

type base_tuple = (int * float)

type base = { b0: int; b1: bool }

type 'a array = 'a Atdgen_runtime.Util.ocaml_array

type 'a abs3 = 'a list

type 'a abs2 = 'a list

type 'a abs1 = 'a list

(* Writers for type test_variant *)

val test_variant_tag : Bi_io.node_tag
  (** Tag used by the writers for type {!test_variant}.
      Readers may support more than just this tag. *)

val write_untagged_test_variant :
  Bi_outbuf.t -> test_variant -> unit
  (** Output an untagged biniou value of type {!test_variant}. *)

val write_test_variant :
  Bi_outbuf.t -> test_variant -> unit
  (** Output a biniou value of type {!test_variant}. *)

val string_of_test_variant :
  ?len:int -> test_variant -> string
  (** Serialize a value of type {!test_variant} into
      a biniou string. *)

(* Readers for type test_variant *)

val get_test_variant_reader :
  Bi_io.node_tag -> (Bi_inbuf.t -> test_variant)
  (** Return a function that reads an untagged
      biniou value of type {!test_variant}. *)

val read_test_variant :
  Bi_inbuf.t -> test_variant
  (** Input a tagged biniou value of type {!test_variant}. *)

val test_variant_of_string :
  ?pos:int -> string -> test_variant
  (** Deserialize a biniou value of type {!test_variant}.
      @param pos specifies the position where
                 reading starts. Default: 0. *)


(* Writers for type poly *)

val poly_tag : Bi_io.node_tag
  (** Tag used by the writers for type {!poly}.
      Readers may support more than just this tag. *)

val write_untagged_poly :
  Bi_io.node_tag ->
  (Bi_outbuf.t -> 'x -> unit) ->
  (Bi_outbuf.t -> 'x -> unit) ->
  Bi_io.node_tag ->
  (Bi_outbuf.t -> 'y -> unit) ->
  (Bi_outbuf.t -> 'y -> unit) ->
  Bi_outbuf.t -> ('x, 'y) poly -> unit
  (** Output an untagged biniou value of type {!poly}. *)

val write_poly :
  Bi_io.node_tag ->
  (Bi_outbuf.t -> 'x -> unit) ->
  (Bi_outbuf.t -> 'x -> unit) ->
  Bi_io.node_tag ->
  (Bi_outbuf.t -> 'y -> unit) ->
  (Bi_outbuf.t -> 'y -> unit) ->
  Bi_outbuf.t -> ('x, 'y) poly -> unit
  (** Output a biniou value of type {!poly}. *)

val string_of_poly :
  Bi_io.node_tag ->
  (Bi_outbuf.t -> 'x -> unit) ->
  (Bi_outbuf.t -> 'x -> unit) ->
  Bi_io.node_tag ->
  (Bi_outbuf.t -> 'y -> unit) ->
  (Bi_outbuf.t -> 'y -> unit) ->
  ?len:int -> ('x, 'y) poly -> string
  (** Serialize a value of type {!poly} into
      a biniou string. *)

(* Readers for type poly *)

val get_poly_reader :
  (Bi_io.node_tag -> (Bi_inbuf.t -> 'x)) ->
  (Bi_inbuf.t -> 'x) ->
  (Bi_io.node_tag -> (Bi_inbuf.t -> 'y)) ->
  (Bi_inbuf.t -> 'y) ->
  Bi_io.node_tag -> (Bi_inbuf.t -> ('x, 'y) poly)
  (** Return a function that reads an untagged
      biniou value of type {!poly}. *)

val read_poly :
  (Bi_io.node_tag -> (Bi_inbuf.t -> 'x)) ->
  (Bi_inbuf.t -> 'x) ->
  (Bi_io.node_tag -> (Bi_inbuf.t -> 'y)) ->
  (Bi_inbuf.t -> 'y) ->
  Bi_inbuf.t -> ('x, 'y) poly
  (** Input a tagged biniou value of type {!poly}. *)

val poly_of_string :
  (Bi_io.node_tag -> (Bi_inbuf.t -> 'x)) ->
  (Bi_inbuf.t -> 'x) ->
  (Bi_io.node_tag -> (Bi_inbuf.t -> 'y)) ->
  (Bi_inbuf.t -> 'y) ->
  ?pos:int -> string -> ('x, 'y) poly
  (** Deserialize a biniou value of type {!poly}.
      @param pos specifies the position where
                 reading starts. Default: 0. *)

val create_poly :
  fst: 'x list ->
  snd: ('x, 'y) poly option ->
  unit -> ('x, 'y) poly
  (** Create a record of type {!poly}. *)


(* Writers for type p' *)

val p'_tag : Bi_io.node_tag
  (** Tag used by the writers for type {!p'}.
      Readers may support more than just this tag. *)

val write_untagged_p' :
  Bi_io.node_tag ->
  (Bi_outbuf.t -> 'a -> unit) ->
  (Bi_outbuf.t -> 'a -> unit) ->
  Bi_outbuf.t -> 'a p' -> unit
  (** Output an untagged biniou value of type {!p'}. *)

val write_p' :
  Bi_io.node_tag ->
  (Bi_outbuf.t -> 'a -> unit) ->
  (Bi_outbuf.t -> 'a -> unit) ->
  Bi_outbuf.t -> 'a p' -> unit
  (** Output a biniou value of type {!p'}. *)

val string_of_p' :
  Bi_io.node_tag ->
  (Bi_outbuf.t -> 'a -> unit) ->
  (Bi_outbuf.t -> 'a -> unit) ->
  ?len:int -> 'a p' -> string
  (** Serialize a value of type {!p'} into
      a biniou string. *)

(* Readers for type p' *)

val get_p'_reader :
  (Bi_io.node_tag -> (Bi_inbuf.t -> 'a)) ->
  (Bi_inbuf.t -> 'a) ->
  Bi_io.node_tag -> (Bi_inbuf.t -> 'a p')
  (** Return a function that reads an untagged
      biniou value of type {!p'}. *)

val read_p' :
  (Bi_io.node_tag -> (Bi_inbuf.t -> 'a)) ->
  (Bi_inbuf.t -> 'a) ->
  Bi_inbuf.t -> 'a p'
  (** Input a tagged biniou value of type {!p'}. *)

val p'_of_string :
  (Bi_io.node_tag -> (Bi_inbuf.t -> 'a)) ->
  (Bi_inbuf.t -> 'a) ->
  ?pos:int -> string -> 'a p'
  (** Deserialize a biniou value of type {!p'}.
      @param pos specifies the position where
                 reading starts. Default: 0. *)


(* Writers for type p *)

val p_tag : Bi_io.node_tag
  (** Tag used by the writers for type {!p}.
      Readers may support more than just this tag. *)

val write_untagged_p :
  Bi_outbuf.t -> p -> unit
  (** Output an untagged biniou value of type {!p}. *)

val write_p :
  Bi_outbuf.t -> p -> unit
  (** Output a biniou value of type {!p}. *)

val string_of_p :
  ?len:int -> p -> string
  (** Serialize a value of type {!p} into
      a biniou string. *)

(* Readers for type p *)

val get_p_reader :
  Bi_io.node_tag -> (Bi_inbuf.t -> p)
  (** Return a function that reads an untagged
      biniou value of type {!p}. *)

val read_p :
  Bi_inbuf.t -> p
  (** Input a tagged biniou value of type {!p}. *)

val p_of_string :
  ?pos:int -> string -> p
  (** Deserialize a biniou value of type {!p}.
      @param pos specifies the position where
                 reading starts. Default: 0. *)


(* Writers for type r *)

val r_tag : Bi_io.node_tag
  (** Tag used by the writers for type {!r}.
      Readers may support more than just this tag. *)

val write_untagged_r :
  Bi_outbuf.t -> r -> unit
  (** Output an untagged biniou value of type {!r}. *)

val write_r :
  Bi_outbuf.t -> r -> unit
  (** Output a biniou value of type {!r}. *)

val string_of_r :
  ?len:int -> r -> string
  (** Serialize a value of type {!r} into
      a biniou string. *)

(* Readers for type r *)

val get_r_reader :
  Bi_io.node_tag -> (Bi_inbuf.t -> r)
  (** Return a function that reads an untagged
      biniou value of type {!r}. *)

val read_r :
  Bi_inbuf.t -> r
  (** Input a tagged biniou value of type {!r}. *)

val r_of_string :
  ?pos:int -> string -> r
  (** Deserialize a biniou value of type {!r}.
      @param pos specifies the position where
                 reading starts. Default: 0. *)

val create_r :
  a: int ->
  b: bool ->
  c: p ->
  unit -> r
  (** Create a record of type {!r}. *)


(* Writers for type validated_string_check *)

val validated_string_check_tag : Bi_io.node_tag
  (** Tag used by the writers for type {!validated_string_check}.
      Readers may support more than just this tag. *)

val write_untagged_validated_string_check :
  Bi_outbuf.t -> validated_string_check -> unit
  (** Output an untagged biniou value of type {!validated_string_check}. *)

val write_validated_string_check :
  Bi_outbuf.t -> validated_string_check -> unit
  (** Output a biniou value of type {!validated_string_check}. *)

val string_of_validated_string_check :
  ?len:int -> validated_string_check -> string
  (** Serialize a value of type {!validated_string_check} into
      a biniou string. *)

(* Readers for type validated_string_check *)

val get_validated_string_check_reader :
  Bi_io.node_tag -> (Bi_inbuf.t -> validated_string_check)
  (** Return a function that reads an untagged
      biniou value of type {!validated_string_check}. *)

val read_validated_string_check :
  Bi_inbuf.t -> validated_string_check
  (** Input a tagged biniou value of type {!validated_string_check}. *)

val validated_string_check_of_string :
  ?pos:int -> string -> validated_string_check
  (** Deserialize a biniou value of type {!validated_string_check}.
      @param pos specifies the position where
                 reading starts. Default: 0. *)


(* Writers for type validate_me *)

val validate_me_tag : Bi_io.node_tag
  (** Tag used by the writers for type {!validate_me}.
      Readers may support more than just this tag. *)

val write_untagged_validate_me :
  Bi_outbuf.t -> validate_me -> unit
  (** Output an untagged biniou value of type {!validate_me}. *)

val write_validate_me :
  Bi_outbuf.t -> validate_me -> unit
  (** Output a biniou value of type {!validate_me}. *)

val string_of_validate_me :
  ?len:int -> validate_me -> string
  (** Serialize a value of type {!validate_me} into
      a biniou string. *)

(* Readers for type validate_me *)

val get_validate_me_reader :
  Bi_io.node_tag -> (Bi_inbuf.t -> validate_me)
  (** Return a function that reads an untagged
      biniou value of type {!validate_me}. *)

val read_validate_me :
  Bi_inbuf.t -> validate_me
  (** Input a tagged biniou value of type {!validate_me}. *)

val validate_me_of_string :
  ?pos:int -> string -> validate_me
  (** Deserialize a biniou value of type {!validate_me}.
      @param pos specifies the position where
                 reading starts. Default: 0. *)


(* Writers for type val1 *)

val val1_tag : Bi_io.node_tag
  (** Tag used by the writers for type {!val1}.
      Readers may support more than just this tag. *)

val write_untagged_val1 :
  Bi_outbuf.t -> val1 -> unit
  (** Output an untagged biniou value of type {!val1}. *)

val write_val1 :
  Bi_outbuf.t -> val1 -> unit
  (** Output a biniou value of type {!val1}. *)

val string_of_val1 :
  ?len:int -> val1 -> string
  (** Serialize a value of type {!val1} into
      a biniou string. *)

(* Readers for type val1 *)

val get_val1_reader :
  Bi_io.node_tag -> (Bi_inbuf.t -> val1)
  (** Return a function that reads an untagged
      biniou value of type {!val1}. *)

val read_val1 :
  Bi_inbuf.t -> val1
  (** Input a tagged biniou value of type {!val1}. *)

val val1_of_string :
  ?pos:int -> string -> val1
  (** Deserialize a biniou value of type {!val1}.
      @param pos specifies the position where
                 reading starts. Default: 0. *)

val create_val1 :
  val1_x: int ->
  unit -> val1
  (** Create a record of type {!val1}. *)


(* Writers for type val2 *)

val val2_tag : Bi_io.node_tag
  (** Tag used by the writers for type {!val2}.
      Readers may support more than just this tag. *)

val write_untagged_val2 :
  Bi_outbuf.t -> val2 -> unit
  (** Output an untagged biniou value of type {!val2}. *)

val write_val2 :
  Bi_outbuf.t -> val2 -> unit
  (** Output a biniou value of type {!val2}. *)

val string_of_val2 :
  ?len:int -> val2 -> string
  (** Serialize a value of type {!val2} into
      a biniou string. *)

(* Readers for type val2 *)

val get_val2_reader :
  Bi_io.node_tag -> (Bi_inbuf.t -> val2)
  (** Return a function that reads an untagged
      biniou value of type {!val2}. *)

val read_val2 :
  Bi_inbuf.t -> val2
  (** Input a tagged biniou value of type {!val2}. *)

val val2_of_string :
  ?pos:int -> string -> val2
  (** Deserialize a biniou value of type {!val2}.
      @param pos specifies the position where
                 reading starts. Default: 0. *)

val create_val2 :
  val2_x: val1 ->
  ?val2_y: val1 ->
  unit -> val2
  (** Create a record of type {!val2}. *)


(* Writers for type unixtime_list *)

val unixtime_list_tag : Bi_io.node_tag
  (** Tag used by the writers for type {!unixtime_list}.
      Readers may support more than just this tag. *)

val write_untagged_unixtime_list :
  Bi_outbuf.t -> unixtime_list -> unit
  (** Output an untagged biniou value of type {!unixtime_list}. *)

val write_unixtime_list :
  Bi_outbuf.t -> unixtime_list -> unit
  (** Output a biniou value of type {!unixtime_list}. *)

val string_of_unixtime_list :
  ?len:int -> unixtime_list -> string
  (** Serialize a value of type {!unixtime_list} into
      a biniou string. *)

(* Readers for type unixtime_list *)

val get_unixtime_list_reader :
  Bi_io.node_tag -> (Bi_inbuf.t -> unixtime_list)
  (** Return a function that reads an untagged
      biniou value of type {!unixtime_list}. *)

val read_unixtime_list :
  Bi_inbuf.t -> unixtime_list
  (** Input a tagged biniou value of type {!unixtime_list}. *)

val unixtime_list_of_string :
  ?pos:int -> string -> unixtime_list
  (** Deserialize a biniou value of type {!unixtime_list}.
      @param pos specifies the position where
                 reading starts. Default: 0. *)


(* Writers for type date *)

val date_tag : Bi_io.node_tag
  (** Tag used by the writers for type {!date}.
      Readers may support more than just this tag. *)

val write_untagged_date :
  Bi_outbuf.t -> date -> unit
  (** Output an untagged biniou value of type {!date}. *)

val write_date :
  Bi_outbuf.t -> date -> unit
  (** Output a biniou value of type {!date}. *)

val string_of_date :
  ?len:int -> date -> string
  (** Serialize a value of type {!date} into
      a biniou string. *)

(* Readers for type date *)

val get_date_reader :
  Bi_io.node_tag -> (Bi_inbuf.t -> date)
  (** Return a function that reads an untagged
      biniou value of type {!date}. *)

val read_date :
  Bi_inbuf.t -> date
  (** Input a tagged biniou value of type {!date}. *)

val date_of_string :
  ?pos:int -> string -> date
  (** Deserialize a biniou value of type {!date}.
      @param pos specifies the position where
                 reading starts. Default: 0. *)


(* Writers for type mixed_record *)

val mixed_record_tag : Bi_io.node_tag
  (** Tag used by the writers for type {!mixed_record}.
      Readers may support more than just this tag. *)

val write_untagged_mixed_record :
  Bi_outbuf.t -> mixed_record -> unit
  (** Output an untagged biniou value of type {!mixed_record}. *)

val write_mixed_record :
  Bi_outbuf.t -> mixed_record -> unit
  (** Output a biniou value of type {!mixed_record}. *)

val string_of_mixed_record :
  ?len:int -> mixed_record -> string
  (** Serialize a value of type {!mixed_record} into
      a biniou string. *)

(* Readers for type mixed_record *)

val get_mixed_record_reader :
  Bi_io.node_tag -> (Bi_inbuf.t -> mixed_record)
  (** Return a function that reads an untagged
      biniou value of type {!mixed_record}. *)

val read_mixed_record :
  Bi_inbuf.t -> mixed_record
  (** Input a tagged biniou value of type {!mixed_record}. *)

val mixed_record_of_string :
  ?pos:int -> string -> mixed_record
  (** Deserialize a biniou value of type {!mixed_record}.
      @param pos specifies the position where
                 reading starts. Default: 0. *)

val create_mixed_record :
  ?field0: int ->
  ?field1: float ->
  field2: string option ->
  field3: Int64.t ->
  field4: float Atdgen_runtime.Util.ocaml_array ->
  ?field5: bool ->
  ?field6: string ->
  field7: test_variant ->
  field8: string Atdgen_runtime.Util.ocaml_array ->
  field9: (int * int * Char.t * int * Int32.t * Int64.t) ->
  field10: bool ->
  ?field11: bool ->
  field12: unit list ->
  field13: string option list ->
  field14: date ->
  unit -> mixed_record
  (** Create a record of type {!mixed_record}. *)


(* Writers for type mixed *)

val mixed_tag : Bi_io.node_tag
  (** Tag used by the writers for type {!mixed}.
      Readers may support more than just this tag. *)

val write_untagged_mixed :
  Bi_outbuf.t -> mixed -> unit
  (** Output an untagged biniou value of type {!mixed}. *)

val write_mixed :
  Bi_outbuf.t -> mixed -> unit
  (** Output a biniou value of type {!mixed}. *)

val string_of_mixed :
  ?len:int -> mixed -> string
  (** Serialize a value of type {!mixed} into
      a biniou string. *)

(* Readers for type mixed *)

val get_mixed_reader :
  Bi_io.node_tag -> (Bi_inbuf.t -> mixed)
  (** Return a function that reads an untagged
      biniou value of type {!mixed}. *)

val read_mixed :
  Bi_inbuf.t -> mixed
  (** Input a tagged biniou value of type {!mixed}. *)

val mixed_of_string :
  ?pos:int -> string -> mixed
  (** Deserialize a biniou value of type {!mixed}.
      @param pos specifies the position where
                 reading starts. Default: 0. *)


(* Writers for type test *)

val test_tag : Bi_io.node_tag
  (** Tag used by the writers for type {!test}.
      Readers may support more than just this tag. *)

val write_untagged_test :
  Bi_outbuf.t -> test -> unit
  (** Output an untagged biniou value of type {!test}. *)

val write_test :
  Bi_outbuf.t -> test -> unit
  (** Output a biniou value of type {!test}. *)

val string_of_test :
  ?len:int -> test -> string
  (** Serialize a value of type {!test} into
      a biniou string. *)

(* Readers for type test *)

val get_test_reader :
  Bi_io.node_tag -> (Bi_inbuf.t -> test)
  (** Return a function that reads an untagged
      biniou value of type {!test}. *)

val read_test :
  Bi_inbuf.t -> test
  (** Input a tagged biniou value of type {!test}. *)

val test_of_string :
  ?pos:int -> string -> test
  (** Deserialize a biniou value of type {!test}.
      @param pos specifies the position where
                 reading starts. Default: 0. *)

val create_test :
  ?x0: int ->
  ?x1: float ->
  x2: mixed ->
  x3: mixed_record list ->
  x4: Int64.t ->
  unit -> test
  (** Create a record of type {!test}. *)


(* Writers for type tup *)

val tup_tag : Bi_io.node_tag
  (** Tag used by the writers for type {!tup}.
      Readers may support more than just this tag. *)

val write_untagged_tup :
  Bi_outbuf.t -> tup -> unit
  (** Output an untagged biniou value of type {!tup}. *)

val write_tup :
  Bi_outbuf.t -> tup -> unit
  (** Output a biniou value of type {!tup}. *)

val string_of_tup :
  ?len:int -> tup -> string
  (** Serialize a value of type {!tup} into
      a biniou string. *)

(* Readers for type tup *)

val get_tup_reader :
  Bi_io.node_tag -> (Bi_inbuf.t -> tup)
  (** Return a function that reads an untagged
      biniou value of type {!tup}. *)

val read_tup :
  Bi_inbuf.t -> tup
  (** Input a tagged biniou value of type {!tup}. *)

val tup_of_string :
  ?pos:int -> string -> tup
  (** Deserialize a biniou value of type {!tup}.
      @param pos specifies the position where
                 reading starts. Default: 0. *)


(* Writers for type star_rating *)

val star_rating_tag : Bi_io.node_tag
  (** Tag used by the writers for type {!star_rating}.
      Readers may support more than just this tag. *)

val write_untagged_star_rating :
  Bi_outbuf.t -> star_rating -> unit
  (** Output an untagged biniou value of type {!star_rating}. *)

val write_star_rating :
  Bi_outbuf.t -> star_rating -> unit
  (** Output a biniou value of type {!star_rating}. *)

val string_of_star_rating :
  ?len:int -> star_rating -> string
  (** Serialize a value of type {!star_rating} into
      a biniou string. *)

(* Readers for type star_rating *)

val get_star_rating_reader :
  Bi_io.node_tag -> (Bi_inbuf.t -> star_rating)
  (** Return a function that reads an untagged
      biniou value of type {!star_rating}. *)

val read_star_rating :
  Bi_inbuf.t -> star_rating
  (** Input a tagged biniou value of type {!star_rating}. *)

val star_rating_of_string :
  ?pos:int -> string -> star_rating
  (** Deserialize a biniou value of type {!star_rating}.
      @param pos specifies the position where
                 reading starts. Default: 0. *)


(* Writers for type generic *)

val generic_tag : Bi_io.node_tag
  (** Tag used by the writers for type {!generic}.
      Readers may support more than just this tag. *)

val write_untagged_generic :
  Bi_io.node_tag ->
  (Bi_outbuf.t -> 'a -> unit) ->
  (Bi_outbuf.t -> 'a -> unit) ->
  Bi_outbuf.t -> 'a generic -> unit
  (** Output an untagged biniou value of type {!generic}. *)

val write_generic :
  Bi_io.node_tag ->
  (Bi_outbuf.t -> 'a -> unit) ->
  (Bi_outbuf.t -> 'a -> unit) ->
  Bi_outbuf.t -> 'a generic -> unit
  (** Output a biniou value of type {!generic}. *)

val string_of_generic :
  Bi_io.node_tag ->
  (Bi_outbuf.t -> 'a -> unit) ->
  (Bi_outbuf.t -> 'a -> unit) ->
  ?len:int -> 'a generic -> string
  (** Serialize a value of type {!generic} into
      a biniou string. *)

(* Readers for type generic *)

val get_generic_reader :
  (Bi_io.node_tag -> (Bi_inbuf.t -> 'a)) ->
  (Bi_inbuf.t -> 'a) ->
  Bi_io.node_tag -> (Bi_inbuf.t -> 'a generic)
  (** Return a function that reads an untagged
      biniou value of type {!generic}. *)

val read_generic :
  (Bi_io.node_tag -> (Bi_inbuf.t -> 'a)) ->
  (Bi_inbuf.t -> 'a) ->
  Bi_inbuf.t -> 'a generic
  (** Input a tagged biniou value of type {!generic}. *)

val generic_of_string :
  (Bi_io.node_tag -> (Bi_inbuf.t -> 'a)) ->
  (Bi_inbuf.t -> 'a) ->
  ?pos:int -> string -> 'a generic
  (** Deserialize a biniou value of type {!generic}.
      @param pos specifies the position where
                 reading starts. Default: 0. *)

val create_generic :
  x294623: int ->
  unit -> 'a generic
  (** Create a record of type {!generic}. *)


(* Writers for type specialized *)

val specialized_tag : Bi_io.node_tag
  (** Tag used by the writers for type {!specialized}.
      Readers may support more than just this tag. *)

val write_untagged_specialized :
  Bi_outbuf.t -> specialized -> unit
  (** Output an untagged biniou value of type {!specialized}. *)

val write_specialized :
  Bi_outbuf.t -> specialized -> unit
  (** Output a biniou value of type {!specialized}. *)

val string_of_specialized :
  ?len:int -> specialized -> string
  (** Serialize a value of type {!specialized} into
      a biniou string. *)

(* Readers for type specialized *)

val get_specialized_reader :
  Bi_io.node_tag -> (Bi_inbuf.t -> specialized)
  (** Return a function that reads an untagged
      biniou value of type {!specialized}. *)

val read_specialized :
  Bi_inbuf.t -> specialized
  (** Input a tagged biniou value of type {!specialized}. *)

val specialized_of_string :
  ?pos:int -> string -> specialized
  (** Deserialize a biniou value of type {!specialized}.
      @param pos specifies the position where
                 reading starts. Default: 0. *)


(* Writers for type some_record *)

val some_record_tag : Bi_io.node_tag
  (** Tag used by the writers for type {!some_record}.
      Readers may support more than just this tag. *)

val write_untagged_some_record :
  Bi_outbuf.t -> some_record -> unit
  (** Output an untagged biniou value of type {!some_record}. *)

val write_some_record :
  Bi_outbuf.t -> some_record -> unit
  (** Output a biniou value of type {!some_record}. *)

val string_of_some_record :
  ?len:int -> some_record -> string
  (** Serialize a value of type {!some_record} into
      a biniou string. *)

(* Readers for type some_record *)

val get_some_record_reader :
  Bi_io.node_tag -> (Bi_inbuf.t -> some_record)
  (** Return a function that reads an untagged
      biniou value of type {!some_record}. *)

val read_some_record :
  Bi_inbuf.t -> some_record
  (** Input a tagged biniou value of type {!some_record}. *)

val some_record_of_string :
  ?pos:int -> string -> some_record
  (** Deserialize a biniou value of type {!some_record}.
      @param pos specifies the position where
                 reading starts. Default: 0. *)

val create_some_record :
  some_field: int ->
  unit -> some_record
  (** Create a record of type {!some_record}. *)


(* Writers for type precision *)

val precision_tag : Bi_io.node_tag
  (** Tag used by the writers for type {!precision}.
      Readers may support more than just this tag. *)

val write_untagged_precision :
  Bi_outbuf.t -> precision -> unit
  (** Output an untagged biniou value of type {!precision}. *)

val write_precision :
  Bi_outbuf.t -> precision -> unit
  (** Output a biniou value of type {!precision}. *)

val string_of_precision :
  ?len:int -> precision -> string
  (** Serialize a value of type {!precision} into
      a biniou string. *)

(* Readers for type precision *)

val get_precision_reader :
  Bi_io.node_tag -> (Bi_inbuf.t -> precision)
  (** Return a function that reads an untagged
      biniou value of type {!precision}. *)

val read_precision :
  Bi_inbuf.t -> precision
  (** Input a tagged biniou value of type {!precision}. *)

val precision_of_string :
  ?pos:int -> string -> precision
  (** Deserialize a biniou value of type {!precision}.
      @param pos specifies the position where
                 reading starts. Default: 0. *)

val create_precision :
  sqrt2_5: float ->
  small_2: float ->
  large_2: float ->
  unit -> precision
  (** Create a record of type {!precision}. *)


(* Writers for type p'' *)

val p''_tag : Bi_io.node_tag
  (** Tag used by the writers for type {!p''}.
      Readers may support more than just this tag. *)

val write_untagged_p'' :
  Bi_outbuf.t -> p'' -> unit
  (** Output an untagged biniou value of type {!p''}. *)

val write_p'' :
  Bi_outbuf.t -> p'' -> unit
  (** Output a biniou value of type {!p''}. *)

val string_of_p'' :
  ?len:int -> p'' -> string
  (** Serialize a value of type {!p''} into
      a biniou string. *)

(* Readers for type p'' *)

val get_p''_reader :
  Bi_io.node_tag -> (Bi_inbuf.t -> p'')
  (** Return a function that reads an untagged
      biniou value of type {!p''}. *)

val read_p'' :
  Bi_inbuf.t -> p''
  (** Input a tagged biniou value of type {!p''}. *)

val p''_of_string :
  ?pos:int -> string -> p''
  (** Deserialize a biniou value of type {!p''}.
      @param pos specifies the position where
                 reading starts. Default: 0. *)


(* Writers for type option_validation *)

val option_validation_tag : Bi_io.node_tag
  (** Tag used by the writers for type {!option_validation}.
      Readers may support more than just this tag. *)

val write_untagged_option_validation :
  Bi_outbuf.t -> option_validation -> unit
  (** Output an untagged biniou value of type {!option_validation}. *)

val write_option_validation :
  Bi_outbuf.t -> option_validation -> unit
  (** Output a biniou value of type {!option_validation}. *)

val string_of_option_validation :
  ?len:int -> option_validation -> string
  (** Serialize a value of type {!option_validation} into
      a biniou string. *)

(* Readers for type option_validation *)

val get_option_validation_reader :
  Bi_io.node_tag -> (Bi_inbuf.t -> option_validation)
  (** Return a function that reads an untagged
      biniou value of type {!option_validation}. *)

val read_option_validation :
  Bi_inbuf.t -> option_validation
  (** Input a tagged biniou value of type {!option_validation}. *)

val option_validation_of_string :
  ?pos:int -> string -> option_validation
  (** Deserialize a biniou value of type {!option_validation}.
      @param pos specifies the position where
                 reading starts. Default: 0. *)


(* Writers for type no_real_wrap *)

val no_real_wrap_tag : Bi_io.node_tag
  (** Tag used by the writers for type {!no_real_wrap}.
      Readers may support more than just this tag. *)

val write_untagged_no_real_wrap :
  Bi_outbuf.t -> no_real_wrap -> unit
  (** Output an untagged biniou value of type {!no_real_wrap}. *)

val write_no_real_wrap :
  Bi_outbuf.t -> no_real_wrap -> unit
  (** Output a biniou value of type {!no_real_wrap}. *)

val string_of_no_real_wrap :
  ?len:int -> no_real_wrap -> string
  (** Serialize a value of type {!no_real_wrap} into
      a biniou string. *)

(* Readers for type no_real_wrap *)

val get_no_real_wrap_reader :
  Bi_io.node_tag -> (Bi_inbuf.t -> no_real_wrap)
  (** Return a function that reads an untagged
      biniou value of type {!no_real_wrap}. *)

val read_no_real_wrap :
  Bi_inbuf.t -> no_real_wrap
  (** Input a tagged biniou value of type {!no_real_wrap}. *)

val no_real_wrap_of_string :
  ?pos:int -> string -> no_real_wrap
  (** Deserialize a biniou value of type {!no_real_wrap}.
      @param pos specifies the position where
                 reading starts. Default: 0. *)


(* Writers for type natural *)

val natural_tag : Bi_io.node_tag
  (** Tag used by the writers for type {!natural}.
      Readers may support more than just this tag. *)

val write_untagged_natural :
  Bi_outbuf.t -> natural -> unit
  (** Output an untagged biniou value of type {!natural}. *)

val write_natural :
  Bi_outbuf.t -> natural -> unit
  (** Output a biniou value of type {!natural}. *)

val string_of_natural :
  ?len:int -> natural -> string
  (** Serialize a value of type {!natural} into
      a biniou string. *)

(* Readers for type natural *)

val get_natural_reader :
  Bi_io.node_tag -> (Bi_inbuf.t -> natural)
  (** Return a function that reads an untagged
      biniou value of type {!natural}. *)

val read_natural :
  Bi_inbuf.t -> natural
  (** Input a tagged biniou value of type {!natural}. *)

val natural_of_string :
  ?pos:int -> string -> natural
  (** Deserialize a biniou value of type {!natural}.
      @param pos specifies the position where
                 reading starts. Default: 0. *)


(* Writers for type id *)

val id_tag : Bi_io.node_tag
  (** Tag used by the writers for type {!id}.
      Readers may support more than just this tag. *)

val write_untagged_id :
  Bi_outbuf.t -> id -> unit
  (** Output an untagged biniou value of type {!id}. *)

val write_id :
  Bi_outbuf.t -> id -> unit
  (** Output a biniou value of type {!id}. *)

val string_of_id :
  ?len:int -> id -> string
  (** Serialize a value of type {!id} into
      a biniou string. *)

(* Readers for type id *)

val get_id_reader :
  Bi_io.node_tag -> (Bi_inbuf.t -> id)
  (** Return a function that reads an untagged
      biniou value of type {!id}. *)

val read_id :
  Bi_inbuf.t -> id
  (** Input a tagged biniou value of type {!id}. *)

val id_of_string :
  ?pos:int -> string -> id
  (** Deserialize a biniou value of type {!id}.
      @param pos specifies the position where
                 reading starts. Default: 0. *)


(* Writers for type json_map *)

val json_map_tag : Bi_io.node_tag
  (** Tag used by the writers for type {!json_map}.
      Readers may support more than just this tag. *)

val write_untagged_json_map :
  Bi_outbuf.t -> json_map -> unit
  (** Output an untagged biniou value of type {!json_map}. *)

val write_json_map :
  Bi_outbuf.t -> json_map -> unit
  (** Output a biniou value of type {!json_map}. *)

val string_of_json_map :
  ?len:int -> json_map -> string
  (** Serialize a value of type {!json_map} into
      a biniou string. *)

(* Readers for type json_map *)

val get_json_map_reader :
  Bi_io.node_tag -> (Bi_inbuf.t -> json_map)
  (** Return a function that reads an untagged
      biniou value of type {!json_map}. *)

val read_json_map :
  Bi_inbuf.t -> json_map
  (** Input a tagged biniou value of type {!json_map}. *)

val json_map_of_string :
  ?pos:int -> string -> json_map
  (** Deserialize a biniou value of type {!json_map}.
      @param pos specifies the position where
                 reading starts. Default: 0. *)


(* Writers for type intopt *)

val intopt_tag : Bi_io.node_tag
  (** Tag used by the writers for type {!intopt}.
      Readers may support more than just this tag. *)

val write_untagged_intopt :
  Bi_outbuf.t -> intopt -> unit
  (** Output an untagged biniou value of type {!intopt}. *)

val write_intopt :
  Bi_outbuf.t -> intopt -> unit
  (** Output a biniou value of type {!intopt}. *)

val string_of_intopt :
  ?len:int -> intopt -> string
  (** Serialize a value of type {!intopt} into
      a biniou string. *)

(* Readers for type intopt *)

val get_intopt_reader :
  Bi_io.node_tag -> (Bi_inbuf.t -> intopt)
  (** Return a function that reads an untagged
      biniou value of type {!intopt}. *)

val read_intopt :
  Bi_inbuf.t -> intopt
  (** Input a tagged biniou value of type {!intopt}. *)

val intopt_of_string :
  ?pos:int -> string -> intopt
  (** Deserialize a biniou value of type {!intopt}.
      @param pos specifies the position where
                 reading starts. Default: 0. *)


(* Writers for type int_assoc_list *)

val int_assoc_list_tag : Bi_io.node_tag
  (** Tag used by the writers for type {!int_assoc_list}.
      Readers may support more than just this tag. *)

val write_untagged_int_assoc_list :
  Bi_outbuf.t -> int_assoc_list -> unit
  (** Output an untagged biniou value of type {!int_assoc_list}. *)

val write_int_assoc_list :
  Bi_outbuf.t -> int_assoc_list -> unit
  (** Output a biniou value of type {!int_assoc_list}. *)

val string_of_int_assoc_list :
  ?len:int -> int_assoc_list -> string
  (** Serialize a value of type {!int_assoc_list} into
      a biniou string. *)

(* Readers for type int_assoc_list *)

val get_int_assoc_list_reader :
  Bi_io.node_tag -> (Bi_inbuf.t -> int_assoc_list)
  (** Return a function that reads an untagged
      biniou value of type {!int_assoc_list}. *)

val read_int_assoc_list :
  Bi_inbuf.t -> int_assoc_list
  (** Input a tagged biniou value of type {!int_assoc_list}. *)

val int_assoc_list_of_string :
  ?pos:int -> string -> int_assoc_list
  (** Deserialize a biniou value of type {!int_assoc_list}.
      @param pos specifies the position where
                 reading starts. Default: 0. *)


(* Writers for type int_assoc_array *)

val int_assoc_array_tag : Bi_io.node_tag
  (** Tag used by the writers for type {!int_assoc_array}.
      Readers may support more than just this tag. *)

val write_untagged_int_assoc_array :
  Bi_outbuf.t -> int_assoc_array -> unit
  (** Output an untagged biniou value of type {!int_assoc_array}. *)

val write_int_assoc_array :
  Bi_outbuf.t -> int_assoc_array -> unit
  (** Output a biniou value of type {!int_assoc_array}. *)

val string_of_int_assoc_array :
  ?len:int -> int_assoc_array -> string
  (** Serialize a value of type {!int_assoc_array} into
      a biniou string. *)

(* Readers for type int_assoc_array *)

val get_int_assoc_array_reader :
  Bi_io.node_tag -> (Bi_inbuf.t -> int_assoc_array)
  (** Return a function that reads an untagged
      biniou value of type {!int_assoc_array}. *)

val read_int_assoc_array :
  Bi_inbuf.t -> int_assoc_array
  (** Input a tagged biniou value of type {!int_assoc_array}. *)

val int_assoc_array_of_string :
  ?pos:int -> string -> int_assoc_array
  (** Deserialize a biniou value of type {!int_assoc_array}.
      @param pos specifies the position where
                 reading starts. Default: 0. *)


(* Writers for type int8 *)

val int8_tag : Bi_io.node_tag
  (** Tag used by the writers for type {!int8}.
      Readers may support more than just this tag. *)

val write_untagged_int8 :
  Bi_outbuf.t -> int8 -> unit
  (** Output an untagged biniou value of type {!int8}. *)

val write_int8 :
  Bi_outbuf.t -> int8 -> unit
  (** Output a biniou value of type {!int8}. *)

val string_of_int8 :
  ?len:int -> int8 -> string
  (** Serialize a value of type {!int8} into
      a biniou string. *)

(* Readers for type int8 *)

val get_int8_reader :
  Bi_io.node_tag -> (Bi_inbuf.t -> int8)
  (** Return a function that reads an untagged
      biniou value of type {!int8}. *)

val read_int8 :
  Bi_inbuf.t -> int8
  (** Input a tagged biniou value of type {!int8}. *)

val int8_of_string :
  ?pos:int -> string -> int8
  (** Deserialize a biniou value of type {!int8}.
      @param pos specifies the position where
                 reading starts. Default: 0. *)


(* Writers for type int64 *)

val int64_tag : Bi_io.node_tag
  (** Tag used by the writers for type {!int64}.
      Readers may support more than just this tag. *)

val write_untagged_int64 :
  Bi_outbuf.t -> int64 -> unit
  (** Output an untagged biniou value of type {!int64}. *)

val write_int64 :
  Bi_outbuf.t -> int64 -> unit
  (** Output a biniou value of type {!int64}. *)

val string_of_int64 :
  ?len:int -> int64 -> string
  (** Serialize a value of type {!int64} into
      a biniou string. *)

(* Readers for type int64 *)

val get_int64_reader :
  Bi_io.node_tag -> (Bi_inbuf.t -> int64)
  (** Return a function that reads an untagged
      biniou value of type {!int64}. *)

val read_int64 :
  Bi_inbuf.t -> int64
  (** Input a tagged biniou value of type {!int64}. *)

val int64_of_string :
  ?pos:int -> string -> int64
  (** Deserialize a biniou value of type {!int64}.
      @param pos specifies the position where
                 reading starts. Default: 0. *)


(* Writers for type int32 *)

val int32_tag : Bi_io.node_tag
  (** Tag used by the writers for type {!int32}.
      Readers may support more than just this tag. *)

val write_untagged_int32 :
  Bi_outbuf.t -> int32 -> unit
  (** Output an untagged biniou value of type {!int32}. *)

val write_int32 :
  Bi_outbuf.t -> int32 -> unit
  (** Output a biniou value of type {!int32}. *)

val string_of_int32 :
  ?len:int -> int32 -> string
  (** Serialize a value of type {!int32} into
      a biniou string. *)

(* Readers for type int32 *)

val get_int32_reader :
  Bi_io.node_tag -> (Bi_inbuf.t -> int32)
  (** Return a function that reads an untagged
      biniou value of type {!int32}. *)

val read_int32 :
  Bi_inbuf.t -> int32
  (** Input a tagged biniou value of type {!int32}. *)

val int32_of_string :
  ?pos:int -> string -> int32
  (** Deserialize a biniou value of type {!int32}.
      @param pos specifies the position where
                 reading starts. Default: 0. *)


(* Writers for type hello *)

val hello_tag : Bi_io.node_tag
  (** Tag used by the writers for type {!hello}.
      Readers may support more than just this tag. *)

val write_untagged_hello :
  Bi_outbuf.t -> hello -> unit
  (** Output an untagged biniou value of type {!hello}. *)

val write_hello :
  Bi_outbuf.t -> hello -> unit
  (** Output a biniou value of type {!hello}. *)

val string_of_hello :
  ?len:int -> hello -> string
  (** Serialize a value of type {!hello} into
      a biniou string. *)

(* Readers for type hello *)

val get_hello_reader :
  Bi_io.node_tag -> (Bi_inbuf.t -> hello)
  (** Return a function that reads an untagged
      biniou value of type {!hello}. *)

val read_hello :
  Bi_inbuf.t -> hello
  (** Input a tagged biniou value of type {!hello}. *)

val hello_of_string :
  ?pos:int -> string -> hello
  (** Deserialize a biniou value of type {!hello}.
      @param pos specifies the position where
                 reading starts. Default: 0. *)


(* Writers for type floats *)

val floats_tag : Bi_io.node_tag
  (** Tag used by the writers for type {!floats}.
      Readers may support more than just this tag. *)

val write_untagged_floats :
  Bi_outbuf.t -> floats -> unit
  (** Output an untagged biniou value of type {!floats}. *)

val write_floats :
  Bi_outbuf.t -> floats -> unit
  (** Output a biniou value of type {!floats}. *)

val string_of_floats :
  ?len:int -> floats -> string
  (** Serialize a value of type {!floats} into
      a biniou string. *)

(* Readers for type floats *)

val get_floats_reader :
  Bi_io.node_tag -> (Bi_inbuf.t -> floats)
  (** Return a function that reads an untagged
      biniou value of type {!floats}. *)

val read_floats :
  Bi_inbuf.t -> floats
  (** Input a tagged biniou value of type {!floats}. *)

val floats_of_string :
  ?pos:int -> string -> floats
  (** Deserialize a biniou value of type {!floats}.
      @param pos specifies the position where
                 reading starts. Default: 0. *)

val create_floats :
  f32: float ->
  f64: float ->
  unit -> floats
  (** Create a record of type {!floats}. *)


(* Writers for type extended_tuple *)

val extended_tuple_tag : Bi_io.node_tag
  (** Tag used by the writers for type {!extended_tuple}.
      Readers may support more than just this tag. *)

val write_untagged_extended_tuple :
  Bi_outbuf.t -> extended_tuple -> unit
  (** Output an untagged biniou value of type {!extended_tuple}. *)

val write_extended_tuple :
  Bi_outbuf.t -> extended_tuple -> unit
  (** Output a biniou value of type {!extended_tuple}. *)

val string_of_extended_tuple :
  ?len:int -> extended_tuple -> string
  (** Serialize a value of type {!extended_tuple} into
      a biniou string. *)

(* Readers for type extended_tuple *)

val get_extended_tuple_reader :
  Bi_io.node_tag -> (Bi_inbuf.t -> extended_tuple)
  (** Return a function that reads an untagged
      biniou value of type {!extended_tuple}. *)

val read_extended_tuple :
  Bi_inbuf.t -> extended_tuple
  (** Input a tagged biniou value of type {!extended_tuple}. *)

val extended_tuple_of_string :
  ?pos:int -> string -> extended_tuple
  (** Deserialize a biniou value of type {!extended_tuple}.
      @param pos specifies the position where
                 reading starts. Default: 0. *)


(* Writers for type extended *)

val extended_tag : Bi_io.node_tag
  (** Tag used by the writers for type {!extended}.
      Readers may support more than just this tag. *)

val write_untagged_extended :
  Bi_outbuf.t -> extended -> unit
  (** Output an untagged biniou value of type {!extended}. *)

val write_extended :
  Bi_outbuf.t -> extended -> unit
  (** Output a biniou value of type {!extended}. *)

val string_of_extended :
  ?len:int -> extended -> string
  (** Serialize a value of type {!extended} into
      a biniou string. *)

(* Readers for type extended *)

val get_extended_reader :
  Bi_io.node_tag -> (Bi_inbuf.t -> extended)
  (** Return a function that reads an untagged
      biniou value of type {!extended}. *)

val read_extended :
  Bi_inbuf.t -> extended
  (** Input a tagged biniou value of type {!extended}. *)

val extended_of_string :
  ?pos:int -> string -> extended
  (** Deserialize a biniou value of type {!extended}.
      @param pos specifies the position where
                 reading starts. Default: 0. *)

val create_extended :
  b0x: int ->
  b1x: bool ->
  b2x: string ->
  ?b3x: string ->
  b4x: string option ->
  ?b5x: float ->
  unit -> extended
  (** Create a record of type {!extended}. *)


(* Writers for type even_natural *)

val even_natural_tag : Bi_io.node_tag
  (** Tag used by the writers for type {!even_natural}.
      Readers may support more than just this tag. *)

val write_untagged_even_natural :
  Bi_outbuf.t -> even_natural -> unit
  (** Output an untagged biniou value of type {!even_natural}. *)

val write_even_natural :
  Bi_outbuf.t -> even_natural -> unit
  (** Output a biniou value of type {!even_natural}. *)

val string_of_even_natural :
  ?len:int -> even_natural -> string
  (** Serialize a value of type {!even_natural} into
      a biniou string. *)

(* Readers for type even_natural *)

val get_even_natural_reader :
  Bi_io.node_tag -> (Bi_inbuf.t -> even_natural)
  (** Return a function that reads an untagged
      biniou value of type {!even_natural}. *)

val read_even_natural :
  Bi_inbuf.t -> even_natural
  (** Input a tagged biniou value of type {!even_natural}. *)

val even_natural_of_string :
  ?pos:int -> string -> even_natural
  (** Deserialize a biniou value of type {!even_natural}.
      @param pos specifies the position where
                 reading starts. Default: 0. *)


(* Writers for type def *)

val def_tag : Bi_io.node_tag
  (** Tag used by the writers for type {!def}.
      Readers may support more than just this tag. *)

val write_untagged_def :
  Bi_outbuf.t -> def -> unit
  (** Output an untagged biniou value of type {!def}. *)

val write_def :
  Bi_outbuf.t -> def -> unit
  (** Output a biniou value of type {!def}. *)

val string_of_def :
  ?len:int -> def -> string
  (** Serialize a value of type {!def} into
      a biniou string. *)

(* Readers for type def *)

val get_def_reader :
  Bi_io.node_tag -> (Bi_inbuf.t -> def)
  (** Return a function that reads an untagged
      biniou value of type {!def}. *)

val read_def :
  Bi_inbuf.t -> def
  (** Input a tagged biniou value of type {!def}. *)

val def_of_string :
  ?pos:int -> string -> def
  (** Deserialize a biniou value of type {!def}.
      @param pos specifies the position where
                 reading starts. Default: 0. *)


(* Writers for type char *)

val char_tag : Bi_io.node_tag
  (** Tag used by the writers for type {!char}.
      Readers may support more than just this tag. *)

val write_untagged_char :
  Bi_outbuf.t -> char -> unit
  (** Output an untagged biniou value of type {!char}. *)

val write_char :
  Bi_outbuf.t -> char -> unit
  (** Output a biniou value of type {!char}. *)

val string_of_char :
  ?len:int -> char -> string
  (** Serialize a value of type {!char} into
      a biniou string. *)

(* Readers for type char *)

val get_char_reader :
  Bi_io.node_tag -> (Bi_inbuf.t -> char)
  (** Return a function that reads an untagged
      biniou value of type {!char}. *)

val read_char :
  Bi_inbuf.t -> char
  (** Input a tagged biniou value of type {!char}. *)

val char_of_string :
  ?pos:int -> string -> char
  (** Deserialize a biniou value of type {!char}.
      @param pos specifies the position where
                 reading starts. Default: 0. *)


(* Writers for type base_tuple *)

val base_tuple_tag : Bi_io.node_tag
  (** Tag used by the writers for type {!base_tuple}.
      Readers may support more than just this tag. *)

val write_untagged_base_tuple :
  Bi_outbuf.t -> base_tuple -> unit
  (** Output an untagged biniou value of type {!base_tuple}. *)

val write_base_tuple :
  Bi_outbuf.t -> base_tuple -> unit
  (** Output a biniou value of type {!base_tuple}. *)

val string_of_base_tuple :
  ?len:int -> base_tuple -> string
  (** Serialize a value of type {!base_tuple} into
      a biniou string. *)

(* Readers for type base_tuple *)

val get_base_tuple_reader :
  Bi_io.node_tag -> (Bi_inbuf.t -> base_tuple)
  (** Return a function that reads an untagged
      biniou value of type {!base_tuple}. *)

val read_base_tuple :
  Bi_inbuf.t -> base_tuple
  (** Input a tagged biniou value of type {!base_tuple}. *)

val base_tuple_of_string :
  ?pos:int -> string -> base_tuple
  (** Deserialize a biniou value of type {!base_tuple}.
      @param pos specifies the position where
                 reading starts. Default: 0. *)


(* Writers for type base *)

val base_tag : Bi_io.node_tag
  (** Tag used by the writers for type {!base}.
      Readers may support more than just this tag. *)

val write_untagged_base :
  Bi_outbuf.t -> base -> unit
  (** Output an untagged biniou value of type {!base}. *)

val write_base :
  Bi_outbuf.t -> base -> unit
  (** Output a biniou value of type {!base}. *)

val string_of_base :
  ?len:int -> base -> string
  (** Serialize a value of type {!base} into
      a biniou string. *)

(* Readers for type base *)

val get_base_reader :
  Bi_io.node_tag -> (Bi_inbuf.t -> base)
  (** Return a function that reads an untagged
      biniou value of type {!base}. *)

val read_base :
  Bi_inbuf.t -> base
  (** Input a tagged biniou value of type {!base}. *)

val base_of_string :
  ?pos:int -> string -> base
  (** Deserialize a biniou value of type {!base}.
      @param pos specifies the position where
                 reading starts. Default: 0. *)

val create_base :
  b0: int ->
  b1: bool ->
  unit -> base
  (** Create a record of type {!base}. *)


(* Writers for type array *)

val array_tag : Bi_io.node_tag
  (** Tag used by the writers for type {!array}.
      Readers may support more than just this tag. *)

val write_untagged_array :
  Bi_io.node_tag ->
  (Bi_outbuf.t -> 'a -> unit) ->
  (Bi_outbuf.t -> 'a -> unit) ->
  Bi_outbuf.t -> 'a array -> unit
  (** Output an untagged biniou value of type {!array}. *)

val write_array :
  Bi_io.node_tag ->
  (Bi_outbuf.t -> 'a -> unit) ->
  (Bi_outbuf.t -> 'a -> unit) ->
  Bi_outbuf.t -> 'a array -> unit
  (** Output a biniou value of type {!array}. *)

val string_of_array :
  Bi_io.node_tag ->
  (Bi_outbuf.t -> 'a -> unit) ->
  (Bi_outbuf.t -> 'a -> unit) ->
  ?len:int -> 'a array -> string
  (** Serialize a value of type {!array} into
      a biniou string. *)

(* Readers for type array *)

val get_array_reader :
  (Bi_io.node_tag -> (Bi_inbuf.t -> 'a)) ->
  (Bi_inbuf.t -> 'a) ->
  Bi_io.node_tag -> (Bi_inbuf.t -> 'a array)
  (** Return a function that reads an untagged
      biniou value of type {!array}. *)

val read_array :
  (Bi_io.node_tag -> (Bi_inbuf.t -> 'a)) ->
  (Bi_inbuf.t -> 'a) ->
  Bi_inbuf.t -> 'a array
  (** Input a tagged biniou value of type {!array}. *)

val array_of_string :
  (Bi_io.node_tag -> (Bi_inbuf.t -> 'a)) ->
  (Bi_inbuf.t -> 'a) ->
  ?pos:int -> string -> 'a array
  (** Deserialize a biniou value of type {!array}.
      @param pos specifies the position where
                 reading starts. Default: 0. *)


(* Writers for type abs3 *)

val abs3_tag : Bi_io.node_tag
  (** Tag used by the writers for type {!abs3}.
      Readers may support more than just this tag. *)

val write_untagged_abs3 :
  Bi_io.node_tag ->
  (Bi_outbuf.t -> 'a -> unit) ->
  (Bi_outbuf.t -> 'a -> unit) ->
  Bi_outbuf.t -> 'a abs3 -> unit
  (** Output an untagged biniou value of type {!abs3}. *)

val write_abs3 :
  Bi_io.node_tag ->
  (Bi_outbuf.t -> 'a -> unit) ->
  (Bi_outbuf.t -> 'a -> unit) ->
  Bi_outbuf.t -> 'a abs3 -> unit
  (** Output a biniou value of type {!abs3}. *)

val string_of_abs3 :
  Bi_io.node_tag ->
  (Bi_outbuf.t -> 'a -> unit) ->
  (Bi_outbuf.t -> 'a -> unit) ->
  ?len:int -> 'a abs3 -> string
  (** Serialize a value of type {!abs3} into
      a biniou string. *)

(* Readers for type abs3 *)

val get_abs3_reader :
  (Bi_io.node_tag -> (Bi_inbuf.t -> 'a)) ->
  (Bi_inbuf.t -> 'a) ->
  Bi_io.node_tag -> (Bi_inbuf.t -> 'a abs3)
  (** Return a function that reads an untagged
      biniou value of type {!abs3}. *)

val read_abs3 :
  (Bi_io.node_tag -> (Bi_inbuf.t -> 'a)) ->
  (Bi_inbuf.t -> 'a) ->
  Bi_inbuf.t -> 'a abs3
  (** Input a tagged biniou value of type {!abs3}. *)

val abs3_of_string :
  (Bi_io.node_tag -> (Bi_inbuf.t -> 'a)) ->
  (Bi_inbuf.t -> 'a) ->
  ?pos:int -> string -> 'a abs3
  (** Deserialize a biniou value of type {!abs3}.
      @param pos specifies the position where
                 reading starts. Default: 0. *)


(* Writers for type abs2 *)

val abs2_tag : Bi_io.node_tag
  (** Tag used by the writers for type {!abs2}.
      Readers may support more than just this tag. *)

val write_untagged_abs2 :
  Bi_io.node_tag ->
  (Bi_outbuf.t -> 'a -> unit) ->
  (Bi_outbuf.t -> 'a -> unit) ->
  Bi_outbuf.t -> 'a abs2 -> unit
  (** Output an untagged biniou value of type {!abs2}. *)

val write_abs2 :
  Bi_io.node_tag ->
  (Bi_outbuf.t -> 'a -> unit) ->
  (Bi_outbuf.t -> 'a -> unit) ->
  Bi_outbuf.t -> 'a abs2 -> unit
  (** Output a biniou value of type {!abs2}. *)

val string_of_abs2 :
  Bi_io.node_tag ->
  (Bi_outbuf.t -> 'a -> unit) ->
  (Bi_outbuf.t -> 'a -> unit) ->
  ?len:int -> 'a abs2 -> string
  (** Serialize a value of type {!abs2} into
      a biniou string. *)

(* Readers for type abs2 *)

val get_abs2_reader :
  (Bi_io.node_tag -> (Bi_inbuf.t -> 'a)) ->
  (Bi_inbuf.t -> 'a) ->
  Bi_io.node_tag -> (Bi_inbuf.t -> 'a abs2)
  (** Return a function that reads an untagged
      biniou value of type {!abs2}. *)

val read_abs2 :
  (Bi_io.node_tag -> (Bi_inbuf.t -> 'a)) ->
  (Bi_inbuf.t -> 'a) ->
  Bi_inbuf.t -> 'a abs2
  (** Input a tagged biniou value of type {!abs2}. *)

val abs2_of_string :
  (Bi_io.node_tag -> (Bi_inbuf.t -> 'a)) ->
  (Bi_inbuf.t -> 'a) ->
  ?pos:int -> string -> 'a abs2
  (** Deserialize a biniou value of type {!abs2}.
      @param pos specifies the position where
                 reading starts. Default: 0. *)


(* Writers for type abs1 *)

val abs1_tag : Bi_io.node_tag
  (** Tag used by the writers for type {!abs1}.
      Readers may support more than just this tag. *)

val write_untagged_abs1 :
  Bi_io.node_tag ->
  (Bi_outbuf.t -> 'a -> unit) ->
  (Bi_outbuf.t -> 'a -> unit) ->
  Bi_outbuf.t -> 'a abs1 -> unit
  (** Output an untagged biniou value of type {!abs1}. *)

val write_abs1 :
  Bi_io.node_tag ->
  (Bi_outbuf.t -> 'a -> unit) ->
  (Bi_outbuf.t -> 'a -> unit) ->
  Bi_outbuf.t -> 'a abs1 -> unit
  (** Output a biniou value of type {!abs1}. *)

val string_of_abs1 :
  Bi_io.node_tag ->
  (Bi_outbuf.t -> 'a -> unit) ->
  (Bi_outbuf.t -> 'a -> unit) ->
  ?len:int -> 'a abs1 -> string
  (** Serialize a value of type {!abs1} into
      a biniou string. *)

(* Readers for type abs1 *)

val get_abs1_reader :
  (Bi_io.node_tag -> (Bi_inbuf.t -> 'a)) ->
  (Bi_inbuf.t -> 'a) ->
  Bi_io.node_tag -> (Bi_inbuf.t -> 'a abs1)
  (** Return a function that reads an untagged
      biniou value of type {!abs1}. *)

val read_abs1 :
  (Bi_io.node_tag -> (Bi_inbuf.t -> 'a)) ->
  (Bi_inbuf.t -> 'a) ->
  Bi_inbuf.t -> 'a abs1
  (** Input a tagged biniou value of type {!abs1}. *)

val abs1_of_string :
  (Bi_io.node_tag -> (Bi_inbuf.t -> 'a)) ->
  (Bi_inbuf.t -> 'a) ->
  ?pos:int -> string -> 'a abs1
  (** Deserialize a biniou value of type {!abs1}.
      @param pos specifies the position where
                 reading starts. Default: 0. *)


atd-2.1.0/atdgen/test/test2.atd000066400000000000000000000004051357165332000162420ustar00rootroot00000000000000type ('aa, 'bb) poly 
                      = abstract

type poly_int2 = (int, int) poly
type poly_int_string = (int, string) poly

type test2 = {
  test0 : poly_int2;
  test1 : (int, string option) poly
}
atd-2.1.0/atdgen/test/test2.expected.ml000066400000000000000000000206251357165332000177100ustar00rootroot00000000000000(* Auto-generated from "test2.atd" *)
              [@@@ocaml.warning "-27-32-35-39"]
open Test

type ('aa, 'bb) poly = ('aa, 'bb) Test.poly

type poly_int2 = (int, int) poly

type test2 = { test0: poly_int2; test1: (int, string option) poly }

type poly_int_string = (int, string) poly

let poly_tag = Test.poly_tag
let write_untagged_poly _aa_tag write_untagged__aa write__aa _bb_tag write_untagged__bb write__bb = (
  Test.write_untagged_poly _aa_tag write_untagged__aa write__aa _bb_tag write_untagged__bb write__bb
)
let write_poly _aa_tag write_untagged__aa write__aa _bb_tag write_untagged__bb write__bb ob x =
  Bi_io.write_tag ob Test.poly_tag;
  write_untagged_poly _aa_tag write_untagged__aa write__aa _bb_tag write_untagged__bb write__bb ob x
let string_of_poly _aa_tag write_untagged__aa write__aa _bb_tag write_untagged__bb write__bb ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_poly _aa_tag write_untagged__aa write__aa _bb_tag write_untagged__bb write__bb ob x;
  Bi_outbuf.contents ob
let get_poly_reader get__aa_reader read__aa get__bb_reader read__bb = (
  Test.get_poly_reader get__aa_reader read__aa get__bb_reader read__bb
)
let read_poly get__aa_reader read__aa get__bb_reader read__bb = (
  Test.read_poly get__aa_reader read__aa get__bb_reader read__bb
)
let poly_of_string get__aa_reader read__aa get__bb_reader read__bb ?pos s =
  read_poly get__aa_reader read__aa get__bb_reader read__bb (Bi_inbuf.from_string ?pos s)
let _1_tag = Test.poly_tag
let write_untagged__1 = (
  write_untagged_poly Bi_io.svint_tag Bi_io.write_untagged_svint Bi_io.write_svint Bi_io.svint_tag Bi_io.write_untagged_svint Bi_io.write_svint
)
let write__1 ob x =
  Bi_io.write_tag ob Test.poly_tag;
  write_untagged__1 ob x
let string_of__1 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__1 ob x;
  Bi_outbuf.contents ob
let get__1_reader = (
  get_poly_reader Atdgen_runtime.Ob_run.get_int_reader Atdgen_runtime.Ob_run.read_int Atdgen_runtime.Ob_run.get_int_reader Atdgen_runtime.Ob_run.read_int
)
let read__1 = (
  read_poly Atdgen_runtime.Ob_run.get_int_reader Atdgen_runtime.Ob_run.read_int Atdgen_runtime.Ob_run.get_int_reader Atdgen_runtime.Ob_run.read_int
)
let _1_of_string ?pos s =
  read__1 (Bi_inbuf.from_string ?pos s)
let poly_int2_tag = Test.poly_tag
let write_untagged_poly_int2 = (
  write_untagged__1
)
let write_poly_int2 ob x =
  Bi_io.write_tag ob Test.poly_tag;
  write_untagged_poly_int2 ob x
let string_of_poly_int2 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_poly_int2 ob x;
  Bi_outbuf.contents ob
let get_poly_int2_reader = (
  get__1_reader
)
let read_poly_int2 = (
  read__1
)
let poly_int2_of_string ?pos s =
  read_poly_int2 (Bi_inbuf.from_string ?pos s)
let _3_tag = Bi_io.num_variant_tag
let write_untagged__3 = (
  Atdgen_runtime.Ob_run.write_untagged_option (
    Bi_io.write_string
  )
)
let write__3 ob x =
  Bi_io.write_tag ob Bi_io.num_variant_tag;
  write_untagged__3 ob x
let string_of__3 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__3 ob x;
  Bi_outbuf.contents ob
let get__3_reader = (
  fun tag ->
    if tag <> 22 then Atdgen_runtime.Ob_run.read_error () else
      fun ib ->
        match Char.code (Bi_inbuf.read_char ib) with
          | 0 -> None
          | 0x80 ->
            Some (
              (
                Atdgen_runtime.Ob_run.read_string
              )
                ib
            )
          | _ -> Atdgen_runtime.Ob_run.read_error_at ib
)
let read__3 = (
  fun ib ->
    if Bi_io.read_tag ib <> 22 then Atdgen_runtime.Ob_run.read_error_at ib;
    match Char.code (Bi_inbuf.read_char ib) with
      | 0 -> None
      | 0x80 ->
        Some (
          (
            Atdgen_runtime.Ob_run.read_string
          )
            ib
        )
      | _ -> Atdgen_runtime.Ob_run.read_error_at ib
)
let _3_of_string ?pos s =
  read__3 (Bi_inbuf.from_string ?pos s)
let _4_tag = Test.poly_tag
let write_untagged__4 = (
  write_untagged_poly Bi_io.svint_tag Bi_io.write_untagged_svint Bi_io.write_svint _3_tag write_untagged__3 write__3
)
let write__4 ob x =
  Bi_io.write_tag ob Test.poly_tag;
  write_untagged__4 ob x
let string_of__4 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__4 ob x;
  Bi_outbuf.contents ob
let get__4_reader = (
  get_poly_reader Atdgen_runtime.Ob_run.get_int_reader Atdgen_runtime.Ob_run.read_int get__3_reader read__3
)
let read__4 = (
  read_poly Atdgen_runtime.Ob_run.get_int_reader Atdgen_runtime.Ob_run.read_int get__3_reader read__3
)
let _4_of_string ?pos s =
  read__4 (Bi_inbuf.from_string ?pos s)
let test2_tag = Bi_io.record_tag
let write_untagged_test2 : Bi_outbuf.t -> test2 -> unit = (
  fun ob x ->
    Bi_vint.write_uvint ob 2;
    Bi_outbuf.add_char4 ob '\141' '\149' '\127' '\158';
    (
      write_poly_int2
    ) ob x.test0;
    Bi_outbuf.add_char4 ob '\141' '\149' '\127' '\159';
    (
      write__4
    ) ob x.test1;
)
let write_test2 ob x =
  Bi_io.write_tag ob Bi_io.record_tag;
  write_untagged_test2 ob x
let string_of_test2 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_test2 ob x;
  Bi_outbuf.contents ob
let get_test2_reader = (
  fun tag ->
    if tag <> 21 then Atdgen_runtime.Ob_run.read_error () else
      fun ib ->
        let field_test0 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let field_test1 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let bits0 = ref 0 in
        let len = Bi_vint.read_uvint ib in
        for i = 1 to len do
          match Bi_io.read_field_hashtag ib with
            | 227901342 ->
              field_test0 := (
                (
                  read_poly_int2
                ) ib
              );
              bits0 := !bits0 lor 0x1;
            | 227901343 ->
              field_test1 := (
                (
                  read__4
                ) ib
              );
              bits0 := !bits0 lor 0x2;
            | _ -> Bi_io.skip ib
        done;
        if !bits0 <> 0x3 then Atdgen_runtime.Ob_run.missing_fields [| !bits0 |] [| "test0"; "test1" |];
        (
          {
            test0 = !field_test0;
            test1 = !field_test1;
          }
         : test2)
)
let read_test2 = (
  fun ib ->
    if Bi_io.read_tag ib <> 21 then Atdgen_runtime.Ob_run.read_error_at ib;
    let field_test0 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let field_test1 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let bits0 = ref 0 in
    let len = Bi_vint.read_uvint ib in
    for i = 1 to len do
      match Bi_io.read_field_hashtag ib with
        | 227901342 ->
          field_test0 := (
            (
              read_poly_int2
            ) ib
          );
          bits0 := !bits0 lor 0x1;
        | 227901343 ->
          field_test1 := (
            (
              read__4
            ) ib
          );
          bits0 := !bits0 lor 0x2;
        | _ -> Bi_io.skip ib
    done;
    if !bits0 <> 0x3 then Atdgen_runtime.Ob_run.missing_fields [| !bits0 |] [| "test0"; "test1" |];
    (
      {
        test0 = !field_test0;
        test1 = !field_test1;
      }
     : test2)
)
let test2_of_string ?pos s =
  read_test2 (Bi_inbuf.from_string ?pos s)
let _2_tag = Test.poly_tag
let write_untagged__2 = (
  write_untagged_poly Bi_io.svint_tag Bi_io.write_untagged_svint Bi_io.write_svint Bi_io.string_tag Bi_io.write_untagged_string Bi_io.write_string
)
let write__2 ob x =
  Bi_io.write_tag ob Test.poly_tag;
  write_untagged__2 ob x
let string_of__2 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__2 ob x;
  Bi_outbuf.contents ob
let get__2_reader = (
  get_poly_reader Atdgen_runtime.Ob_run.get_int_reader Atdgen_runtime.Ob_run.read_int Atdgen_runtime.Ob_run.get_string_reader Atdgen_runtime.Ob_run.read_string
)
let read__2 = (
  read_poly Atdgen_runtime.Ob_run.get_int_reader Atdgen_runtime.Ob_run.read_int Atdgen_runtime.Ob_run.get_string_reader Atdgen_runtime.Ob_run.read_string
)
let _2_of_string ?pos s =
  read__2 (Bi_inbuf.from_string ?pos s)
let poly_int_string_tag = Test.poly_tag
let write_untagged_poly_int_string = (
  write_untagged__2
)
let write_poly_int_string ob x =
  Bi_io.write_tag ob Test.poly_tag;
  write_untagged_poly_int_string ob x
let string_of_poly_int_string ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_poly_int_string ob x;
  Bi_outbuf.contents ob
let get_poly_int_string_reader = (
  get__2_reader
)
let read_poly_int_string = (
  read__2
)
let poly_int_string_of_string ?pos s =
  read_poly_int_string (Bi_inbuf.from_string ?pos s)
let create_test2 
  ~test0
  ~test1
  () : test2 =
  {
    test0 = test0;
    test1 = test1;
  }
atd-2.1.0/atdgen/test/test2.expected.mli000066400000000000000000000130371357165332000200600ustar00rootroot00000000000000(* Auto-generated from "test2.atd" *)
              [@@@ocaml.warning "-27-32-35-39"]
open Test

type ('aa, 'bb) poly = ('aa, 'bb) Test.poly

type poly_int2 = (int, int) poly

type test2 = { test0: poly_int2; test1: (int, string option) poly }

type poly_int_string = (int, string) poly

(* Writers for type poly *)

val poly_tag : Bi_io.node_tag
  (** Tag used by the writers for type {!poly}.
      Readers may support more than just this tag. *)

val write_untagged_poly :
  Bi_io.node_tag ->
  (Bi_outbuf.t -> 'aa -> unit) ->
  (Bi_outbuf.t -> 'aa -> unit) ->
  Bi_io.node_tag ->
  (Bi_outbuf.t -> 'bb -> unit) ->
  (Bi_outbuf.t -> 'bb -> unit) ->
  Bi_outbuf.t -> ('aa, 'bb) poly -> unit
  (** Output an untagged biniou value of type {!poly}. *)

val write_poly :
  Bi_io.node_tag ->
  (Bi_outbuf.t -> 'aa -> unit) ->
  (Bi_outbuf.t -> 'aa -> unit) ->
  Bi_io.node_tag ->
  (Bi_outbuf.t -> 'bb -> unit) ->
  (Bi_outbuf.t -> 'bb -> unit) ->
  Bi_outbuf.t -> ('aa, 'bb) poly -> unit
  (** Output a biniou value of type {!poly}. *)

val string_of_poly :
  Bi_io.node_tag ->
  (Bi_outbuf.t -> 'aa -> unit) ->
  (Bi_outbuf.t -> 'aa -> unit) ->
  Bi_io.node_tag ->
  (Bi_outbuf.t -> 'bb -> unit) ->
  (Bi_outbuf.t -> 'bb -> unit) ->
  ?len:int -> ('aa, 'bb) poly -> string
  (** Serialize a value of type {!poly} into
      a biniou string. *)

(* Readers for type poly *)

val get_poly_reader :
  (Bi_io.node_tag -> (Bi_inbuf.t -> 'aa)) ->
  (Bi_inbuf.t -> 'aa) ->
  (Bi_io.node_tag -> (Bi_inbuf.t -> 'bb)) ->
  (Bi_inbuf.t -> 'bb) ->
  Bi_io.node_tag -> (Bi_inbuf.t -> ('aa, 'bb) poly)
  (** Return a function that reads an untagged
      biniou value of type {!poly}. *)

val read_poly :
  (Bi_io.node_tag -> (Bi_inbuf.t -> 'aa)) ->
  (Bi_inbuf.t -> 'aa) ->
  (Bi_io.node_tag -> (Bi_inbuf.t -> 'bb)) ->
  (Bi_inbuf.t -> 'bb) ->
  Bi_inbuf.t -> ('aa, 'bb) poly
  (** Input a tagged biniou value of type {!poly}. *)

val poly_of_string :
  (Bi_io.node_tag -> (Bi_inbuf.t -> 'aa)) ->
  (Bi_inbuf.t -> 'aa) ->
  (Bi_io.node_tag -> (Bi_inbuf.t -> 'bb)) ->
  (Bi_inbuf.t -> 'bb) ->
  ?pos:int -> string -> ('aa, 'bb) poly
  (** Deserialize a biniou value of type {!poly}.
      @param pos specifies the position where
                 reading starts. Default: 0. *)


(* Writers for type poly_int2 *)

val poly_int2_tag : Bi_io.node_tag
  (** Tag used by the writers for type {!poly_int2}.
      Readers may support more than just this tag. *)

val write_untagged_poly_int2 :
  Bi_outbuf.t -> poly_int2 -> unit
  (** Output an untagged biniou value of type {!poly_int2}. *)

val write_poly_int2 :
  Bi_outbuf.t -> poly_int2 -> unit
  (** Output a biniou value of type {!poly_int2}. *)

val string_of_poly_int2 :
  ?len:int -> poly_int2 -> string
  (** Serialize a value of type {!poly_int2} into
      a biniou string. *)

(* Readers for type poly_int2 *)

val get_poly_int2_reader :
  Bi_io.node_tag -> (Bi_inbuf.t -> poly_int2)
  (** Return a function that reads an untagged
      biniou value of type {!poly_int2}. *)

val read_poly_int2 :
  Bi_inbuf.t -> poly_int2
  (** Input a tagged biniou value of type {!poly_int2}. *)

val poly_int2_of_string :
  ?pos:int -> string -> poly_int2
  (** Deserialize a biniou value of type {!poly_int2}.
      @param pos specifies the position where
                 reading starts. Default: 0. *)


(* Writers for type test2 *)

val test2_tag : Bi_io.node_tag
  (** Tag used by the writers for type {!test2}.
      Readers may support more than just this tag. *)

val write_untagged_test2 :
  Bi_outbuf.t -> test2 -> unit
  (** Output an untagged biniou value of type {!test2}. *)

val write_test2 :
  Bi_outbuf.t -> test2 -> unit
  (** Output a biniou value of type {!test2}. *)

val string_of_test2 :
  ?len:int -> test2 -> string
  (** Serialize a value of type {!test2} into
      a biniou string. *)

(* Readers for type test2 *)

val get_test2_reader :
  Bi_io.node_tag -> (Bi_inbuf.t -> test2)
  (** Return a function that reads an untagged
      biniou value of type {!test2}. *)

val read_test2 :
  Bi_inbuf.t -> test2
  (** Input a tagged biniou value of type {!test2}. *)

val test2_of_string :
  ?pos:int -> string -> test2
  (** Deserialize a biniou value of type {!test2}.
      @param pos specifies the position where
                 reading starts. Default: 0. *)

val create_test2 :
  test0: poly_int2 ->
  test1: (int, string option) poly ->
  unit -> test2
  (** Create a record of type {!test2}. *)


(* Writers for type poly_int_string *)

val poly_int_string_tag : Bi_io.node_tag
  (** Tag used by the writers for type {!poly_int_string}.
      Readers may support more than just this tag. *)

val write_untagged_poly_int_string :
  Bi_outbuf.t -> poly_int_string -> unit
  (** Output an untagged biniou value of type {!poly_int_string}. *)

val write_poly_int_string :
  Bi_outbuf.t -> poly_int_string -> unit
  (** Output a biniou value of type {!poly_int_string}. *)

val string_of_poly_int_string :
  ?len:int -> poly_int_string -> string
  (** Serialize a value of type {!poly_int_string} into
      a biniou string. *)

(* Readers for type poly_int_string *)

val get_poly_int_string_reader :
  Bi_io.node_tag -> (Bi_inbuf.t -> poly_int_string)
  (** Return a function that reads an untagged
      biniou value of type {!poly_int_string}. *)

val read_poly_int_string :
  Bi_inbuf.t -> poly_int_string
  (** Input a tagged biniou value of type {!poly_int_string}. *)

val poly_int_string_of_string :
  ?pos:int -> string -> poly_int_string
  (** Deserialize a biniou value of type {!poly_int_string}.
      @param pos specifies the position where
                 reading starts. Default: 0. *)


atd-2.1.0/atdgen/test/test2j.expected.ml000066400000000000000000000176751357165332000200750ustar00rootroot00000000000000(* Auto-generated from "test2.atd" *)
[@@@ocaml.warning "-27-32-35-39"]
open Test
open Test2
open Testj

let write_poly write__aa write__bb = (
  Testj.write_poly write__aa write__bb
)
let string_of_poly write__aa write__bb ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_poly write__aa write__bb ob x;
  Bi_outbuf.contents ob
let read_poly read__aa read__bb = (
  Testj.read_poly read__aa read__bb
)
let poly_of_string read__aa read__bb s =
  read_poly read__aa read__bb (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__1 = (
  write_poly Yojson.Safe.write_int Yojson.Safe.write_int
)
let string_of__1 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__1 ob x;
  Bi_outbuf.contents ob
let read__1 = (
  read_poly Atdgen_runtime.Oj_run.read_int Atdgen_runtime.Oj_run.read_int
)
let _1_of_string s =
  read__1 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_poly_int2 = (
  write__1
)
let string_of_poly_int2 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_poly_int2 ob x;
  Bi_outbuf.contents ob
let read_poly_int2 = (
  read__1
)
let poly_int2_of_string s =
  read_poly_int2 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__3 = (
  Atdgen_runtime.Oj_run.write_std_option (
    Yojson.Safe.write_string
  )
)
let string_of__3 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__3 ob x;
  Bi_outbuf.contents ob
let read__3 = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    match Yojson.Safe.start_any_variant p lb with
      | `Edgy_bracket -> (
          match Yojson.Safe.read_ident p lb with
            | "None" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              (None : _ option)
            | "Some" ->
              Atdgen_runtime.Oj_run.read_until_field_value p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_string
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              (Some x : _ option)
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Double_quote -> (
          match Yojson.Safe.finish_string p lb with
            | "None" ->
              (None : _ option)
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Square_bracket -> (
          match Atdgen_runtime.Oj_run.read_string p lb with
            | "Some" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_comma p lb;
              Yojson.Safe.read_space p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_string
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_rbr p lb;
              (Some x : _ option)
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
)
let _3_of_string s =
  read__3 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__4 = (
  write_poly Yojson.Safe.write_int write__3
)
let string_of__4 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__4 ob x;
  Bi_outbuf.contents ob
let read__4 = (
  read_poly Atdgen_runtime.Oj_run.read_int read__3
)
let _4_of_string s =
  read__4 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_test2 : _ -> test2 -> _ = (
  fun ob (x : test2) ->
    Bi_outbuf.add_char ob '{';
    let is_first = ref true in
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"test0\":";
    (
      write_poly_int2
    )
      ob x.test0;
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"test1\":";
    (
      write__4
    )
      ob x.test1;
    Bi_outbuf.add_char ob '}';
)
let string_of_test2 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_test2 ob x;
  Bi_outbuf.contents ob
let read_test2 = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    Yojson.Safe.read_lcurl p lb;
    let field_test0 = ref (None) in
    let field_test1 = ref (None) in
    try
      Yojson.Safe.read_space p lb;
      Yojson.Safe.read_object_end lb;
      Yojson.Safe.read_space p lb;
      let f =
        fun s pos len ->
          if pos < 0 || len < 0 || pos + len > String.length s then
            invalid_arg "out-of-bounds substring position or length";
          if len = 5 && String.unsafe_get s pos = 't' && String.unsafe_get s (pos+1) = 'e' && String.unsafe_get s (pos+2) = 's' && String.unsafe_get s (pos+3) = 't' then (
            match String.unsafe_get s (pos+4) with
              | '0' -> (
                  0
                )
              | '1' -> (
                  1
                )
              | _ -> (
                  -1
                )
          )
          else (
            -1
          )
      in
      let i = Yojson.Safe.map_ident p f lb in
      Atdgen_runtime.Oj_run.read_until_field_value p lb;
      (
        match i with
          | 0 ->
            field_test0 := (
              Some (
                (
                  read_poly_int2
                ) p lb
              )
            );
          | 1 ->
            field_test1 := (
              Some (
                (
                  read__4
                ) p lb
              )
            );
          | _ -> (
              Yojson.Safe.skip_json p lb
            )
      );
      while true do
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_object_sep p lb;
        Yojson.Safe.read_space p lb;
        let f =
          fun s pos len ->
            if pos < 0 || len < 0 || pos + len > String.length s then
              invalid_arg "out-of-bounds substring position or length";
            if len = 5 && String.unsafe_get s pos = 't' && String.unsafe_get s (pos+1) = 'e' && String.unsafe_get s (pos+2) = 's' && String.unsafe_get s (pos+3) = 't' then (
              match String.unsafe_get s (pos+4) with
                | '0' -> (
                    0
                  )
                | '1' -> (
                    1
                  )
                | _ -> (
                    -1
                  )
            )
            else (
              -1
            )
        in
        let i = Yojson.Safe.map_ident p f lb in
        Atdgen_runtime.Oj_run.read_until_field_value p lb;
        (
          match i with
            | 0 ->
              field_test0 := (
                Some (
                  (
                    read_poly_int2
                  ) p lb
                )
              );
            | 1 ->
              field_test1 := (
                Some (
                  (
                    read__4
                  ) p lb
                )
              );
            | _ -> (
                Yojson.Safe.skip_json p lb
              )
        );
      done;
      assert false;
    with Yojson.End_of_object -> (
        (
          {
            test0 = (match !field_test0 with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "test0");
            test1 = (match !field_test1 with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "test1");
          }
         : test2)
      )
)
let test2_of_string s =
  read_test2 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__2 = (
  write_poly Yojson.Safe.write_int Yojson.Safe.write_string
)
let string_of__2 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__2 ob x;
  Bi_outbuf.contents ob
let read__2 = (
  read_poly Atdgen_runtime.Oj_run.read_int Atdgen_runtime.Oj_run.read_string
)
let _2_of_string s =
  read__2 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_poly_int_string = (
  write__2
)
let string_of_poly_int_string ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_poly_int_string ob x;
  Bi_outbuf.contents ob
let read_poly_int_string = (
  read__2
)
let poly_int_string_of_string s =
  read_poly_int_string (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let create_test2 
  ~test0
  ~test1
  () : test2 =
  {
    test0 = test0;
    test1 = test1;
  }
atd-2.1.0/atdgen/test/test2j.expected.mli000066400000000000000000000056701357165332000202360ustar00rootroot00000000000000(* Auto-generated from "test2.atd" *)
[@@@ocaml.warning "-27-32-35-39"]
open Test
open Test2
open Testj

val write_poly :
  (Bi_outbuf.t -> 'aa -> unit) ->
  (Bi_outbuf.t -> 'bb -> unit) ->
  Bi_outbuf.t -> ('aa, 'bb) poly -> unit
  (** Output a JSON value of type {!poly}. *)

val string_of_poly :
  (Bi_outbuf.t -> 'aa -> unit) ->
  (Bi_outbuf.t -> 'bb -> unit) ->
  ?len:int -> ('aa, 'bb) poly -> string
  (** Serialize a value of type {!poly}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_poly :
  (Yojson.Safe.lexer_state -> Lexing.lexbuf -> 'aa) ->
  (Yojson.Safe.lexer_state -> Lexing.lexbuf -> 'bb) ->
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> ('aa, 'bb) poly
  (** Input JSON data of type {!poly}. *)

val poly_of_string :
  (Yojson.Safe.lexer_state -> Lexing.lexbuf -> 'aa) ->
  (Yojson.Safe.lexer_state -> Lexing.lexbuf -> 'bb) ->
  string -> ('aa, 'bb) poly
  (** Deserialize JSON data of type {!poly}. *)


val write_poly_int2 :
  Bi_outbuf.t -> poly_int2 -> unit
  (** Output a JSON value of type {!poly_int2}. *)

val string_of_poly_int2 :
  ?len:int -> poly_int2 -> string
  (** Serialize a value of type {!poly_int2}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_poly_int2 :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> poly_int2
  (** Input JSON data of type {!poly_int2}. *)

val poly_int2_of_string :
  string -> poly_int2
  (** Deserialize JSON data of type {!poly_int2}. *)


val write_test2 :
  Bi_outbuf.t -> test2 -> unit
  (** Output a JSON value of type {!test2}. *)

val string_of_test2 :
  ?len:int -> test2 -> string
  (** Serialize a value of type {!test2}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_test2 :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> test2
  (** Input JSON data of type {!test2}. *)

val test2_of_string :
  string -> test2
  (** Deserialize JSON data of type {!test2}. *)

val create_test2 :
  test0: poly_int2 ->
  test1: (int, string option) poly ->
  unit -> test2
  (** Create a record of type {!test2}. *)


val write_poly_int_string :
  Bi_outbuf.t -> poly_int_string -> unit
  (** Output a JSON value of type {!poly_int_string}. *)

val string_of_poly_int_string :
  ?len:int -> poly_int_string -> string
  (** Serialize a value of type {!poly_int_string}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_poly_int_string :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> poly_int_string
  (** Input JSON data of type {!poly_int_string}. *)

val poly_int_string_of_string :
  string -> poly_int_string
  (** Deserialize JSON data of type {!poly_int_string}. *)


atd-2.1.0/atdgen/test/test3j.atd000066400000000000000000000041051357165332000164160ustar00rootroot00000000000000(* JSON support only *)

type json  = abstract
type dyn  = abstract

type t = {
  foo: int;
  bar: json;
  baz: dyn
}

type unixtime_list = int  list

type patch = {
  ?patch1: int nullable option;
  ?patch2: int nullable option;
  ?patch3: int nullable option;
} 

(*** Test json adapters ***)

(*
   The real json representation uses an object with a `"type"` field
   equal to `"a"` or `"b"`. Types `a` and `b` are incompatible
   with one another.

   See normalize/restore functions in `adapter.ml`.
*)
type adapted = [
  | A  of a
  | B  of b
] 

type a = {
  thing: string;
  other_thing: bool;
}

type b = {
  thing: int; (* field name found in `a` with another type! *)
}

(* Json adapters on recursive types *)

type rec_type = {
  more: rec_type list;
} 

(*
   Test variants represented as single-field json objects.
*)
type sf_adapted = [
  | A  of bool
  | B  of int
] 

(*
   Test substitute for the retired tag_field feature.
*)

type tf_variant = [
  | A  of int
  | B  of int
]

(*
   Sample raw json: { "the_type": "a", "the_value": 123, "etc": "blah" }
   Sample normalized json: { "the_value": ["a", 123], "etc": "blah" }
   Test_lib.Tag_field_example takes care of the conversion
   between the two forms.
*)
type tf_record = {
  the_value : tf_variant;
  etc : string;
} 

type tf_variant2 = [
  | A  of int
  | B  of int
  | Unknown of (string * json nullable)
]

type tf_record2 = {
  the_value2 : tf_variant2;
  etc2 : string;
} 

(*
   Test open_enum feature.
*)
type sample_open_enum = [
  | Alpha
  | Beta
  | Other of string
] 

type sample_open_enums = sample_open_enum list
atd-2.1.0/atdgen/test/test3j_j.expected.ml000066400000000000000000001541111357165332000203720ustar00rootroot00000000000000(* Auto-generated from "test3j.atd" *)
[@@@ocaml.warning "-27-32-35-39"]

type rec_type = Test3j_t.rec_type = { more: rec_type list }

type unixtime_list = Test3j_t.unixtime_list

type json = Yojson.Safe.t

type tf_variant2 = Test3j_t.tf_variant2

type tf_variant = Test3j_t.tf_variant

type tf_record2 = Test3j_t.tf_record2 = {
  the_value2: tf_variant2;
  etc2: string
}

type tf_record = Test3j_t.tf_record = { the_value: tf_variant; etc: string }

type dyn = Yojson.Safe.t

type t = Test3j_t.t = { foo: int; bar: json; baz: dyn }

type sf_adapted = Test3j_t.sf_adapted

type sample_open_enum = Test3j_t.sample_open_enum

type sample_open_enums = Test3j_t.sample_open_enums

type patch = Test3j_t.patch = {
  patch1: int option option;
  patch2: int option option;
  patch3: int option option
}

type b = Test3j_t.b = { thing: int }

type a = Test3j_t.a = { thing: string; other_thing: bool }

type adapted = Test3j_t.adapted

let rec write__4 ob x = (
  Atdgen_runtime.Oj_run.write_list (
    write_rec_type
  )
) ob x
and string_of__4 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__4 ob x;
  Bi_outbuf.contents ob
and write_rec_type ob (x : rec_type) = (
  Atdgen_runtime.Oj_run.write_with_adapter Json_adapters.Identity.restore (
    fun ob (x : rec_type) ->
      Bi_outbuf.add_char ob '{';
      let is_first = ref true in
      if !is_first then
        is_first := false
      else
        Bi_outbuf.add_char ob ',';
      Bi_outbuf.add_string ob "\"more\":";
      (
        write__4
      )
        ob x.more;
      Bi_outbuf.add_char ob '}';
  )
) ob x
and string_of_rec_type ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_rec_type ob x;
  Bi_outbuf.contents ob
let rec read__4 p lb = (
  Atdgen_runtime.Oj_run.read_list (
    read_rec_type
  )
) p lb
and _4_of_string s =
  read__4 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
and read_rec_type p lb = (
  Atdgen_runtime.Oj_run.read_with_adapter Json_adapters.Identity.normalize (
    fun p lb ->
      Yojson.Safe.read_space p lb;
      Yojson.Safe.read_lcurl p lb;
      let field_more = ref (None) in
      try
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_object_end lb;
        Yojson.Safe.read_space p lb;
        let f =
          fun s pos len ->
            if pos < 0 || len < 0 || pos + len > String.length s then
              invalid_arg "out-of-bounds substring position or length";
            if len = 4 && String.unsafe_get s pos = 'm' && String.unsafe_get s (pos+1) = 'o' && String.unsafe_get s (pos+2) = 'r' && String.unsafe_get s (pos+3) = 'e' then (
              0
            )
            else (
              -1
            )
        in
        let i = Yojson.Safe.map_ident p f lb in
        Atdgen_runtime.Oj_run.read_until_field_value p lb;
        (
          match i with
            | 0 ->
              field_more := (
                Some (
                  (
                    read__4
                  ) p lb
                )
              );
            | _ -> (
                Yojson.Safe.skip_json p lb
              )
        );
        while true do
          Yojson.Safe.read_space p lb;
          Yojson.Safe.read_object_sep p lb;
          Yojson.Safe.read_space p lb;
          let f =
            fun s pos len ->
              if pos < 0 || len < 0 || pos + len > String.length s then
                invalid_arg "out-of-bounds substring position or length";
              if len = 4 && String.unsafe_get s pos = 'm' && String.unsafe_get s (pos+1) = 'o' && String.unsafe_get s (pos+2) = 'r' && String.unsafe_get s (pos+3) = 'e' then (
                0
              )
              else (
                -1
              )
          in
          let i = Yojson.Safe.map_ident p f lb in
          Atdgen_runtime.Oj_run.read_until_field_value p lb;
          (
            match i with
              | 0 ->
                field_more := (
                  Some (
                    (
                      read__4
                    ) p lb
                  )
                );
              | _ -> (
                  Yojson.Safe.skip_json p lb
                )
          );
        done;
        assert false;
      with Yojson.End_of_object -> (
          (
            {
              more = (match !field_more with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "more");
            }
           : rec_type)
        )
  )
) p lb
and rec_type_of_string s =
  read_rec_type (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__1 = (
  Atdgen_runtime.Oj_run.write_list (
    Atdgen_runtime.Oj_run.write_float_as_int
  )
)
let string_of__1 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__1 ob x;
  Bi_outbuf.contents ob
let read__1 = (
  Atdgen_runtime.Oj_run.read_list (
    Atdgen_runtime.Oj_run.read_number
  )
)
let _1_of_string s =
  read__1 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_unixtime_list = (
  write__1
)
let string_of_unixtime_list ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_unixtime_list ob x;
  Bi_outbuf.contents ob
let read_unixtime_list = (
  read__1
)
let unixtime_list_of_string s =
  read_unixtime_list (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_json = (
  Yojson.Safe.write_t
)
let string_of_json ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_json ob x;
  Bi_outbuf.contents ob
let read_json = (
  Yojson.Safe.read_t
)
let json_of_string s =
  read_json (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__5 = (
  Atdgen_runtime.Oj_run.write_nullable (
    write_json
  )
)
let string_of__5 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__5 ob x;
  Bi_outbuf.contents ob
let read__5 = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    (if Yojson.Safe.read_null_if_possible p lb then None
    else Some ((
      read_json
    ) p lb) : _ option)
)
let _5_of_string s =
  read__5 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_tf_variant2 = (
  fun ob x ->
    match x with
      | `A x ->
        Bi_outbuf.add_string ob "[\"a\",";
        (
          Yojson.Safe.write_int
        ) ob x;
        Bi_outbuf.add_char ob ']'
      | `B x ->
        Bi_outbuf.add_string ob "[\"b\",";
        (
          Yojson.Safe.write_int
        ) ob x;
        Bi_outbuf.add_char ob ']'
      | `Unknown x ->
        Bi_outbuf.add_string ob "[\"Unknown\",";
        (
          fun ob x ->
            Bi_outbuf.add_char ob '[';
            (let x, _ = x in
            (
              Yojson.Safe.write_string
            ) ob x
            );
            Bi_outbuf.add_char ob ',';
            (let _, x = x in
            (
              write__5
            ) ob x
            );
            Bi_outbuf.add_char ob ']';
        ) ob x;
        Bi_outbuf.add_char ob ']'
)
let string_of_tf_variant2 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_tf_variant2 ob x;
  Bi_outbuf.contents ob
let read_tf_variant2 = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    match Yojson.Safe.start_any_variant p lb with
      | `Edgy_bracket -> (
          match Yojson.Safe.read_ident p lb with
            | "a" ->
              Atdgen_runtime.Oj_run.read_until_field_value p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_int
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              `A x
            | "b" ->
              Atdgen_runtime.Oj_run.read_until_field_value p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_int
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              `B x
            | "Unknown" ->
              Atdgen_runtime.Oj_run.read_until_field_value p lb;
              let x = (
                  fun p lb ->
                    Yojson.Safe.read_space p lb;
                    let std_tuple = Yojson.Safe.start_any_tuple p lb in
                    let len = ref 0 in
                    let end_of_tuple = ref false in
                    (try
                      let x0 =
                        let x =
                          (
                            Atdgen_runtime.Oj_run.read_string
                          ) p lb
                        in
                        incr len;
                        Yojson.Safe.read_space p lb;
                        Yojson.Safe.read_tuple_sep2 p std_tuple lb;
                        x
                      in
                      let x1 =
                        let x =
                          (
                            read__5
                          ) p lb
                        in
                        incr len;
                        (try
                          Yojson.Safe.read_space p lb;
                          Yojson.Safe.read_tuple_sep2 p std_tuple lb;
                        with Yojson.End_of_tuple -> end_of_tuple := true);
                        x
                      in
                      if not !end_of_tuple then (
                        try
                          while true do
                            Yojson.Safe.skip_json p lb;
                            Yojson.Safe.read_space p lb;
                            Yojson.Safe.read_tuple_sep2 p std_tuple lb;
                          done
                        with Yojson.End_of_tuple -> ()
                      );
                      (x0, x1)
                    with Yojson.End_of_tuple ->
                      Atdgen_runtime.Oj_run.missing_tuple_fields p !len [ 0; 1 ]);
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              `Unknown x
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Double_quote -> (
          match Yojson.Safe.finish_string p lb with
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Square_bracket -> (
          match Atdgen_runtime.Oj_run.read_string p lb with
            | "a" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_comma p lb;
              Yojson.Safe.read_space p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_int
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_rbr p lb;
              `A x
            | "b" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_comma p lb;
              Yojson.Safe.read_space p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_int
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_rbr p lb;
              `B x
            | "Unknown" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_comma p lb;
              Yojson.Safe.read_space p lb;
              let x = (
                  fun p lb ->
                    Yojson.Safe.read_space p lb;
                    let std_tuple = Yojson.Safe.start_any_tuple p lb in
                    let len = ref 0 in
                    let end_of_tuple = ref false in
                    (try
                      let x0 =
                        let x =
                          (
                            Atdgen_runtime.Oj_run.read_string
                          ) p lb
                        in
                        incr len;
                        Yojson.Safe.read_space p lb;
                        Yojson.Safe.read_tuple_sep2 p std_tuple lb;
                        x
                      in
                      let x1 =
                        let x =
                          (
                            read__5
                          ) p lb
                        in
                        incr len;
                        (try
                          Yojson.Safe.read_space p lb;
                          Yojson.Safe.read_tuple_sep2 p std_tuple lb;
                        with Yojson.End_of_tuple -> end_of_tuple := true);
                        x
                      in
                      if not !end_of_tuple then (
                        try
                          while true do
                            Yojson.Safe.skip_json p lb;
                            Yojson.Safe.read_space p lb;
                            Yojson.Safe.read_tuple_sep2 p std_tuple lb;
                          done
                        with Yojson.End_of_tuple -> ()
                      );
                      (x0, x1)
                    with Yojson.End_of_tuple ->
                      Atdgen_runtime.Oj_run.missing_tuple_fields p !len [ 0; 1 ]);
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_rbr p lb;
              `Unknown x
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
)
let tf_variant2_of_string s =
  read_tf_variant2 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_tf_variant = (
  fun ob x ->
    match x with
      | `A x ->
        Bi_outbuf.add_string ob "[\"a\",";
        (
          Yojson.Safe.write_int
        ) ob x;
        Bi_outbuf.add_char ob ']'
      | `B x ->
        Bi_outbuf.add_string ob "[\"b\",";
        (
          Yojson.Safe.write_int
        ) ob x;
        Bi_outbuf.add_char ob ']'
)
let string_of_tf_variant ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_tf_variant ob x;
  Bi_outbuf.contents ob
let read_tf_variant = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    match Yojson.Safe.start_any_variant p lb with
      | `Edgy_bracket -> (
          match Yojson.Safe.read_ident p lb with
            | "a" ->
              Atdgen_runtime.Oj_run.read_until_field_value p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_int
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              `A x
            | "b" ->
              Atdgen_runtime.Oj_run.read_until_field_value p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_int
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              `B x
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Double_quote -> (
          match Yojson.Safe.finish_string p lb with
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Square_bracket -> (
          match Atdgen_runtime.Oj_run.read_string p lb with
            | "a" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_comma p lb;
              Yojson.Safe.read_space p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_int
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_rbr p lb;
              `A x
            | "b" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_comma p lb;
              Yojson.Safe.read_space p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_int
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_rbr p lb;
              `B x
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
)
let tf_variant_of_string s =
  read_tf_variant (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_tf_record2 : _ -> tf_record2 -> _ = (
  Atdgen_runtime.Oj_run.write_with_adapter Test_lib.Tag_field_with_catchall.restore (
    fun ob (x : tf_record2) ->
      Bi_outbuf.add_char ob '{';
      let is_first = ref true in
      if !is_first then
        is_first := false
      else
        Bi_outbuf.add_char ob ',';
      Bi_outbuf.add_string ob "\"the_value2\":";
      (
        write_tf_variant2
      )
        ob x.the_value2;
      if !is_first then
        is_first := false
      else
        Bi_outbuf.add_char ob ',';
      Bi_outbuf.add_string ob "\"etc2\":";
      (
        Yojson.Safe.write_string
      )
        ob x.etc2;
      Bi_outbuf.add_char ob '}';
  )
)
let string_of_tf_record2 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_tf_record2 ob x;
  Bi_outbuf.contents ob
let read_tf_record2 = (
  Atdgen_runtime.Oj_run.read_with_adapter Test_lib.Tag_field_with_catchall.normalize (
    fun p lb ->
      Yojson.Safe.read_space p lb;
      Yojson.Safe.read_lcurl p lb;
      let field_the_value2 = ref (None) in
      let field_etc2 = ref (None) in
      try
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_object_end lb;
        Yojson.Safe.read_space p lb;
        let f =
          fun s pos len ->
            if pos < 0 || len < 0 || pos + len > String.length s then
              invalid_arg "out-of-bounds substring position or length";
            match len with
              | 4 -> (
                  if String.unsafe_get s pos = 'e' && String.unsafe_get s (pos+1) = 't' && String.unsafe_get s (pos+2) = 'c' && String.unsafe_get s (pos+3) = '2' then (
                    1
                  )
                  else (
                    -1
                  )
                )
              | 10 -> (
                  if String.unsafe_get s pos = 't' && String.unsafe_get s (pos+1) = 'h' && String.unsafe_get s (pos+2) = 'e' && String.unsafe_get s (pos+3) = '_' && String.unsafe_get s (pos+4) = 'v' && String.unsafe_get s (pos+5) = 'a' && String.unsafe_get s (pos+6) = 'l' && String.unsafe_get s (pos+7) = 'u' && String.unsafe_get s (pos+8) = 'e' && String.unsafe_get s (pos+9) = '2' then (
                    0
                  )
                  else (
                    -1
                  )
                )
              | _ -> (
                  -1
                )
        in
        let i = Yojson.Safe.map_ident p f lb in
        Atdgen_runtime.Oj_run.read_until_field_value p lb;
        (
          match i with
            | 0 ->
              field_the_value2 := (
                Some (
                  (
                    read_tf_variant2
                  ) p lb
                )
              );
            | 1 ->
              field_etc2 := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_string
                  ) p lb
                )
              );
            | _ -> (
                Yojson.Safe.skip_json p lb
              )
        );
        while true do
          Yojson.Safe.read_space p lb;
          Yojson.Safe.read_object_sep p lb;
          Yojson.Safe.read_space p lb;
          let f =
            fun s pos len ->
              if pos < 0 || len < 0 || pos + len > String.length s then
                invalid_arg "out-of-bounds substring position or length";
              match len with
                | 4 -> (
                    if String.unsafe_get s pos = 'e' && String.unsafe_get s (pos+1) = 't' && String.unsafe_get s (pos+2) = 'c' && String.unsafe_get s (pos+3) = '2' then (
                      1
                    )
                    else (
                      -1
                    )
                  )
                | 10 -> (
                    if String.unsafe_get s pos = 't' && String.unsafe_get s (pos+1) = 'h' && String.unsafe_get s (pos+2) = 'e' && String.unsafe_get s (pos+3) = '_' && String.unsafe_get s (pos+4) = 'v' && String.unsafe_get s (pos+5) = 'a' && String.unsafe_get s (pos+6) = 'l' && String.unsafe_get s (pos+7) = 'u' && String.unsafe_get s (pos+8) = 'e' && String.unsafe_get s (pos+9) = '2' then (
                      0
                    )
                    else (
                      -1
                    )
                  )
                | _ -> (
                    -1
                  )
          in
          let i = Yojson.Safe.map_ident p f lb in
          Atdgen_runtime.Oj_run.read_until_field_value p lb;
          (
            match i with
              | 0 ->
                field_the_value2 := (
                  Some (
                    (
                      read_tf_variant2
                    ) p lb
                  )
                );
              | 1 ->
                field_etc2 := (
                  Some (
                    (
                      Atdgen_runtime.Oj_run.read_string
                    ) p lb
                  )
                );
              | _ -> (
                  Yojson.Safe.skip_json p lb
                )
          );
        done;
        assert false;
      with Yojson.End_of_object -> (
          (
            {
              the_value2 = (match !field_the_value2 with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "the_value2");
              etc2 = (match !field_etc2 with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "etc2");
            }
           : tf_record2)
        )
  )
)
let tf_record2_of_string s =
  read_tf_record2 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_tf_record : _ -> tf_record -> _ = (
  Atdgen_runtime.Oj_run.write_with_adapter Test_lib.Tag_field_example.restore (
    fun ob (x : tf_record) ->
      Bi_outbuf.add_char ob '{';
      let is_first = ref true in
      if !is_first then
        is_first := false
      else
        Bi_outbuf.add_char ob ',';
      Bi_outbuf.add_string ob "\"the_value\":";
      (
        write_tf_variant
      )
        ob x.the_value;
      if !is_first then
        is_first := false
      else
        Bi_outbuf.add_char ob ',';
      Bi_outbuf.add_string ob "\"etc\":";
      (
        Yojson.Safe.write_string
      )
        ob x.etc;
      Bi_outbuf.add_char ob '}';
  )
)
let string_of_tf_record ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_tf_record ob x;
  Bi_outbuf.contents ob
let read_tf_record = (
  Atdgen_runtime.Oj_run.read_with_adapter Test_lib.Tag_field_example.normalize (
    fun p lb ->
      Yojson.Safe.read_space p lb;
      Yojson.Safe.read_lcurl p lb;
      let field_the_value = ref (None) in
      let field_etc = ref (None) in
      try
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_object_end lb;
        Yojson.Safe.read_space p lb;
        let f =
          fun s pos len ->
            if pos < 0 || len < 0 || pos + len > String.length s then
              invalid_arg "out-of-bounds substring position or length";
            match len with
              | 3 -> (
                  if String.unsafe_get s pos = 'e' && String.unsafe_get s (pos+1) = 't' && String.unsafe_get s (pos+2) = 'c' then (
                    1
                  )
                  else (
                    -1
                  )
                )
              | 9 -> (
                  if String.unsafe_get s pos = 't' && String.unsafe_get s (pos+1) = 'h' && String.unsafe_get s (pos+2) = 'e' && String.unsafe_get s (pos+3) = '_' && String.unsafe_get s (pos+4) = 'v' && String.unsafe_get s (pos+5) = 'a' && String.unsafe_get s (pos+6) = 'l' && String.unsafe_get s (pos+7) = 'u' && String.unsafe_get s (pos+8) = 'e' then (
                    0
                  )
                  else (
                    -1
                  )
                )
              | _ -> (
                  -1
                )
        in
        let i = Yojson.Safe.map_ident p f lb in
        Atdgen_runtime.Oj_run.read_until_field_value p lb;
        (
          match i with
            | 0 ->
              field_the_value := (
                Some (
                  (
                    read_tf_variant
                  ) p lb
                )
              );
            | 1 ->
              field_etc := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_string
                  ) p lb
                )
              );
            | _ -> (
                Yojson.Safe.skip_json p lb
              )
        );
        while true do
          Yojson.Safe.read_space p lb;
          Yojson.Safe.read_object_sep p lb;
          Yojson.Safe.read_space p lb;
          let f =
            fun s pos len ->
              if pos < 0 || len < 0 || pos + len > String.length s then
                invalid_arg "out-of-bounds substring position or length";
              match len with
                | 3 -> (
                    if String.unsafe_get s pos = 'e' && String.unsafe_get s (pos+1) = 't' && String.unsafe_get s (pos+2) = 'c' then (
                      1
                    )
                    else (
                      -1
                    )
                  )
                | 9 -> (
                    if String.unsafe_get s pos = 't' && String.unsafe_get s (pos+1) = 'h' && String.unsafe_get s (pos+2) = 'e' && String.unsafe_get s (pos+3) = '_' && String.unsafe_get s (pos+4) = 'v' && String.unsafe_get s (pos+5) = 'a' && String.unsafe_get s (pos+6) = 'l' && String.unsafe_get s (pos+7) = 'u' && String.unsafe_get s (pos+8) = 'e' then (
                      0
                    )
                    else (
                      -1
                    )
                  )
                | _ -> (
                    -1
                  )
          in
          let i = Yojson.Safe.map_ident p f lb in
          Atdgen_runtime.Oj_run.read_until_field_value p lb;
          (
            match i with
              | 0 ->
                field_the_value := (
                  Some (
                    (
                      read_tf_variant
                    ) p lb
                  )
                );
              | 1 ->
                field_etc := (
                  Some (
                    (
                      Atdgen_runtime.Oj_run.read_string
                    ) p lb
                  )
                );
              | _ -> (
                  Yojson.Safe.skip_json p lb
                )
          );
        done;
        assert false;
      with Yojson.End_of_object -> (
          (
            {
              the_value = (match !field_the_value with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "the_value");
              etc = (match !field_etc with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "etc");
            }
           : tf_record)
        )
  )
)
let tf_record_of_string s =
  read_tf_record (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_dyn = (
  Yojson.Safe.write_t
)
let string_of_dyn ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_dyn ob x;
  Bi_outbuf.contents ob
let read_dyn = (
  Yojson.Safe.read_t
)
let dyn_of_string s =
  read_dyn (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_t : _ -> t -> _ = (
  fun ob (x : t) ->
    Bi_outbuf.add_char ob '{';
    let is_first = ref true in
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"foo\":";
    (
      Yojson.Safe.write_int
    )
      ob x.foo;
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"bar\":";
    (
      write_json
    )
      ob x.bar;
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"baz\":";
    (
      write_dyn
    )
      ob x.baz;
    Bi_outbuf.add_char ob '}';
)
let string_of_t ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_t ob x;
  Bi_outbuf.contents ob
let read_t = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    Yojson.Safe.read_lcurl p lb;
    let field_foo = ref (None) in
    let field_bar = ref (None) in
    let field_baz = ref (None) in
    try
      Yojson.Safe.read_space p lb;
      Yojson.Safe.read_object_end lb;
      Yojson.Safe.read_space p lb;
      let f =
        fun s pos len ->
          if pos < 0 || len < 0 || pos + len > String.length s then
            invalid_arg "out-of-bounds substring position or length";
          if len = 3 then (
            match String.unsafe_get s pos with
              | 'b' -> (
                  if String.unsafe_get s (pos+1) = 'a' then (
                    match String.unsafe_get s (pos+2) with
                      | 'r' -> (
                          1
                        )
                      | 'z' -> (
                          2
                        )
                      | _ -> (
                          -1
                        )
                  )
                  else (
                    -1
                  )
                )
              | 'f' -> (
                  if String.unsafe_get s (pos+1) = 'o' && String.unsafe_get s (pos+2) = 'o' then (
                    0
                  )
                  else (
                    -1
                  )
                )
              | _ -> (
                  -1
                )
          )
          else (
            -1
          )
      in
      let i = Yojson.Safe.map_ident p f lb in
      Atdgen_runtime.Oj_run.read_until_field_value p lb;
      (
        match i with
          | 0 ->
            field_foo := (
              Some (
                (
                  Atdgen_runtime.Oj_run.read_int
                ) p lb
              )
            );
          | 1 ->
            field_bar := (
              Some (
                (
                  read_json
                ) p lb
              )
            );
          | 2 ->
            field_baz := (
              Some (
                (
                  read_dyn
                ) p lb
              )
            );
          | _ -> (
              Yojson.Safe.skip_json p lb
            )
      );
      while true do
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_object_sep p lb;
        Yojson.Safe.read_space p lb;
        let f =
          fun s pos len ->
            if pos < 0 || len < 0 || pos + len > String.length s then
              invalid_arg "out-of-bounds substring position or length";
            if len = 3 then (
              match String.unsafe_get s pos with
                | 'b' -> (
                    if String.unsafe_get s (pos+1) = 'a' then (
                      match String.unsafe_get s (pos+2) with
                        | 'r' -> (
                            1
                          )
                        | 'z' -> (
                            2
                          )
                        | _ -> (
                            -1
                          )
                    )
                    else (
                      -1
                    )
                  )
                | 'f' -> (
                    if String.unsafe_get s (pos+1) = 'o' && String.unsafe_get s (pos+2) = 'o' then (
                      0
                    )
                    else (
                      -1
                    )
                  )
                | _ -> (
                    -1
                  )
            )
            else (
              -1
            )
        in
        let i = Yojson.Safe.map_ident p f lb in
        Atdgen_runtime.Oj_run.read_until_field_value p lb;
        (
          match i with
            | 0 ->
              field_foo := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_int
                  ) p lb
                )
              );
            | 1 ->
              field_bar := (
                Some (
                  (
                    read_json
                  ) p lb
                )
              );
            | 2 ->
              field_baz := (
                Some (
                  (
                    read_dyn
                  ) p lb
                )
              );
            | _ -> (
                Yojson.Safe.skip_json p lb
              )
        );
      done;
      assert false;
    with Yojson.End_of_object -> (
        (
          {
            foo = (match !field_foo with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "foo");
            bar = (match !field_bar with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "bar");
            baz = (match !field_baz with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "baz");
          }
         : t)
      )
)
let t_of_string s =
  read_t (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_sf_adapted = (
  Atdgen_runtime.Oj_run.write_with_adapter Atdgen_runtime.Json_adapter.One_field.restore (
    fun ob x ->
      match x with
        | `A x ->
          Bi_outbuf.add_string ob "[\"a\",";
          (
            Yojson.Safe.write_bool
          ) ob x;
          Bi_outbuf.add_char ob ']'
        | `B x ->
          Bi_outbuf.add_string ob "[\"b\",";
          (
            Yojson.Safe.write_int
          ) ob x;
          Bi_outbuf.add_char ob ']'
  )
)
let string_of_sf_adapted ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_sf_adapted ob x;
  Bi_outbuf.contents ob
let read_sf_adapted = (
  Atdgen_runtime.Oj_run.read_with_adapter Atdgen_runtime.Json_adapter.One_field.normalize (
    fun p lb ->
      Yojson.Safe.read_space p lb;
      match Yojson.Safe.start_any_variant p lb with
        | `Edgy_bracket -> (
            match Yojson.Safe.read_ident p lb with
              | "a" ->
                Atdgen_runtime.Oj_run.read_until_field_value p lb;
                let x = (
                    Atdgen_runtime.Oj_run.read_bool
                  ) p lb
                in
                Yojson.Safe.read_space p lb;
                Yojson.Safe.read_gt p lb;
                `A x
              | "b" ->
                Atdgen_runtime.Oj_run.read_until_field_value p lb;
                let x = (
                    Atdgen_runtime.Oj_run.read_int
                  ) p lb
                in
                Yojson.Safe.read_space p lb;
                Yojson.Safe.read_gt p lb;
                `B x
              | x ->
                Atdgen_runtime.Oj_run.invalid_variant_tag p x
          )
        | `Double_quote -> (
            match Yojson.Safe.finish_string p lb with
              | x ->
                Atdgen_runtime.Oj_run.invalid_variant_tag p x
          )
        | `Square_bracket -> (
            match Atdgen_runtime.Oj_run.read_string p lb with
              | "a" ->
                Yojson.Safe.read_space p lb;
                Yojson.Safe.read_comma p lb;
                Yojson.Safe.read_space p lb;
                let x = (
                    Atdgen_runtime.Oj_run.read_bool
                  ) p lb
                in
                Yojson.Safe.read_space p lb;
                Yojson.Safe.read_rbr p lb;
                `A x
              | "b" ->
                Yojson.Safe.read_space p lb;
                Yojson.Safe.read_comma p lb;
                Yojson.Safe.read_space p lb;
                let x = (
                    Atdgen_runtime.Oj_run.read_int
                  ) p lb
                in
                Yojson.Safe.read_space p lb;
                Yojson.Safe.read_rbr p lb;
                `B x
              | x ->
                Atdgen_runtime.Oj_run.invalid_variant_tag p x
          )
  )
)
let sf_adapted_of_string s =
  read_sf_adapted (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_sample_open_enum = (
  fun ob x ->
    match x with
      | `Alpha -> Bi_outbuf.add_string ob "\"Alpha\""
      | `Beta -> Bi_outbuf.add_string ob "\"Beta\""
      | `Other x -> (
          Yojson.Safe.write_string
        ) ob x;
)
let string_of_sample_open_enum ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_sample_open_enum ob x;
  Bi_outbuf.contents ob
let read_sample_open_enum = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    match Yojson.Safe.start_any_variant p lb with
      | `Edgy_bracket -> (
          match Yojson.Safe.read_ident p lb with
            | "Alpha" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              `Alpha
            | "Beta" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              `Beta
            | x ->
              `Other x
        )
      | `Double_quote -> (
          match Yojson.Safe.finish_string p lb with
            | "Alpha" ->
              `Alpha
            | "Beta" ->
              `Beta
            | x ->
              `Other x
        )
      | `Square_bracket -> (
          match Atdgen_runtime.Oj_run.read_string p lb with
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
)
let sample_open_enum_of_string s =
  read_sample_open_enum (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__6 = (
  Atdgen_runtime.Oj_run.write_list (
    write_sample_open_enum
  )
)
let string_of__6 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__6 ob x;
  Bi_outbuf.contents ob
let read__6 = (
  Atdgen_runtime.Oj_run.read_list (
    read_sample_open_enum
  )
)
let _6_of_string s =
  read__6 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_sample_open_enums = (
  write__6
)
let string_of_sample_open_enums ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_sample_open_enums ob x;
  Bi_outbuf.contents ob
let read_sample_open_enums = (
  read__6
)
let sample_open_enums_of_string s =
  read_sample_open_enums (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__2 = (
  Atdgen_runtime.Oj_run.write_nullable (
    Yojson.Safe.write_int
  )
)
let string_of__2 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__2 ob x;
  Bi_outbuf.contents ob
let read__2 = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    (if Yojson.Safe.read_null_if_possible p lb then None
    else Some ((
      Atdgen_runtime.Oj_run.read_int
    ) p lb) : _ option)
)
let _2_of_string s =
  read__2 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__3 = (
  Atdgen_runtime.Oj_run.write_std_option (
    write__2
  )
)
let string_of__3 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__3 ob x;
  Bi_outbuf.contents ob
let read__3 = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    match Yojson.Safe.start_any_variant p lb with
      | `Edgy_bracket -> (
          match Yojson.Safe.read_ident p lb with
            | "None" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              (None : _ option)
            | "Some" ->
              Atdgen_runtime.Oj_run.read_until_field_value p lb;
              let x = (
                  read__2
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              (Some x : _ option)
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Double_quote -> (
          match Yojson.Safe.finish_string p lb with
            | "None" ->
              (None : _ option)
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Square_bracket -> (
          match Atdgen_runtime.Oj_run.read_string p lb with
            | "Some" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_comma p lb;
              Yojson.Safe.read_space p lb;
              let x = (
                  read__2
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_rbr p lb;
              (Some x : _ option)
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
)
let _3_of_string s =
  read__3 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_patch : _ -> patch -> _ = (
  fun ob (x : patch) ->
    Bi_outbuf.add_char ob '{';
    let is_first = ref true in
    (match x.patch1 with None -> () | Some x ->
      if !is_first then
        is_first := false
      else
        Bi_outbuf.add_char ob ',';
      Bi_outbuf.add_string ob "\"patch1\":";
      (
        write__2
      )
        ob x;
    );
    (match x.patch2 with None -> () | Some x ->
      if !is_first then
        is_first := false
      else
        Bi_outbuf.add_char ob ',';
      Bi_outbuf.add_string ob "\"patch2\":";
      (
        write__2
      )
        ob x;
    );
    (match x.patch3 with None -> () | Some x ->
      if !is_first then
        is_first := false
      else
        Bi_outbuf.add_char ob ',';
      Bi_outbuf.add_string ob "\"patch3\":";
      (
        write__2
      )
        ob x;
    );
    Bi_outbuf.add_char ob '}';
)
let string_of_patch ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_patch ob x;
  Bi_outbuf.contents ob
let read_patch = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    Yojson.Safe.read_lcurl p lb;
    let field_patch1 = ref (None) in
    let field_patch2 = ref (None) in
    let field_patch3 = ref (None) in
    try
      Yojson.Safe.read_space p lb;
      Yojson.Safe.read_object_end lb;
      Yojson.Safe.read_space p lb;
      let f =
        fun s pos len ->
          if pos < 0 || len < 0 || pos + len > String.length s then
            invalid_arg "out-of-bounds substring position or length";
          if len = 6 && String.unsafe_get s pos = 'p' && String.unsafe_get s (pos+1) = 'a' && String.unsafe_get s (pos+2) = 't' && String.unsafe_get s (pos+3) = 'c' && String.unsafe_get s (pos+4) = 'h' then (
            match String.unsafe_get s (pos+5) with
              | '1' -> (
                  0
                )
              | '2' -> (
                  1
                )
              | '3' -> (
                  2
                )
              | _ -> (
                  -1
                )
          )
          else (
            -1
          )
      in
      let i = Yojson.Safe.map_ident p f lb in
      Atdgen_runtime.Oj_run.read_until_field_value p lb;
      (
        match i with
          | 0 ->
            field_patch1 := (
              Some (
                (
                  read__2
                ) p lb
              )
            );
          | 1 ->
            field_patch2 := (
              Some (
                (
                  read__2
                ) p lb
              )
            );
          | 2 ->
            field_patch3 := (
              Some (
                (
                  read__2
                ) p lb
              )
            );
          | _ -> (
              Yojson.Safe.skip_json p lb
            )
      );
      while true do
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_object_sep p lb;
        Yojson.Safe.read_space p lb;
        let f =
          fun s pos len ->
            if pos < 0 || len < 0 || pos + len > String.length s then
              invalid_arg "out-of-bounds substring position or length";
            if len = 6 && String.unsafe_get s pos = 'p' && String.unsafe_get s (pos+1) = 'a' && String.unsafe_get s (pos+2) = 't' && String.unsafe_get s (pos+3) = 'c' && String.unsafe_get s (pos+4) = 'h' then (
              match String.unsafe_get s (pos+5) with
                | '1' -> (
                    0
                  )
                | '2' -> (
                    1
                  )
                | '3' -> (
                    2
                  )
                | _ -> (
                    -1
                  )
            )
            else (
              -1
            )
        in
        let i = Yojson.Safe.map_ident p f lb in
        Atdgen_runtime.Oj_run.read_until_field_value p lb;
        (
          match i with
            | 0 ->
              field_patch1 := (
                Some (
                  (
                    read__2
                  ) p lb
                )
              );
            | 1 ->
              field_patch2 := (
                Some (
                  (
                    read__2
                  ) p lb
                )
              );
            | 2 ->
              field_patch3 := (
                Some (
                  (
                    read__2
                  ) p lb
                )
              );
            | _ -> (
                Yojson.Safe.skip_json p lb
              )
        );
      done;
      assert false;
    with Yojson.End_of_object -> (
        (
          {
            patch1 = !field_patch1;
            patch2 = !field_patch2;
            patch3 = !field_patch3;
          }
         : patch)
      )
)
let patch_of_string s =
  read_patch (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_b : _ -> b -> _ = (
  fun ob (x : b) ->
    Bi_outbuf.add_char ob '{';
    let is_first = ref true in
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"thing\":";
    (
      Yojson.Safe.write_int
    )
      ob x.thing;
    Bi_outbuf.add_char ob '}';
)
let string_of_b ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_b ob x;
  Bi_outbuf.contents ob
let read_b = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    Yojson.Safe.read_lcurl p lb;
    let field_thing = ref (None) in
    try
      Yojson.Safe.read_space p lb;
      Yojson.Safe.read_object_end lb;
      Yojson.Safe.read_space p lb;
      let f =
        fun s pos len ->
          if pos < 0 || len < 0 || pos + len > String.length s then
            invalid_arg "out-of-bounds substring position or length";
          if len = 5 && String.unsafe_get s pos = 't' && String.unsafe_get s (pos+1) = 'h' && String.unsafe_get s (pos+2) = 'i' && String.unsafe_get s (pos+3) = 'n' && String.unsafe_get s (pos+4) = 'g' then (
            0
          )
          else (
            -1
          )
      in
      let i = Yojson.Safe.map_ident p f lb in
      Atdgen_runtime.Oj_run.read_until_field_value p lb;
      (
        match i with
          | 0 ->
            field_thing := (
              Some (
                (
                  Atdgen_runtime.Oj_run.read_int
                ) p lb
              )
            );
          | _ -> (
              Yojson.Safe.skip_json p lb
            )
      );
      while true do
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_object_sep p lb;
        Yojson.Safe.read_space p lb;
        let f =
          fun s pos len ->
            if pos < 0 || len < 0 || pos + len > String.length s then
              invalid_arg "out-of-bounds substring position or length";
            if len = 5 && String.unsafe_get s pos = 't' && String.unsafe_get s (pos+1) = 'h' && String.unsafe_get s (pos+2) = 'i' && String.unsafe_get s (pos+3) = 'n' && String.unsafe_get s (pos+4) = 'g' then (
              0
            )
            else (
              -1
            )
        in
        let i = Yojson.Safe.map_ident p f lb in
        Atdgen_runtime.Oj_run.read_until_field_value p lb;
        (
          match i with
            | 0 ->
              field_thing := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_int
                  ) p lb
                )
              );
            | _ -> (
                Yojson.Safe.skip_json p lb
              )
        );
      done;
      assert false;
    with Yojson.End_of_object -> (
        (
          {
            thing = (match !field_thing with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "thing");
          }
         : b)
      )
)
let b_of_string s =
  read_b (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_a : _ -> a -> _ = (
  fun ob (x : a) ->
    Bi_outbuf.add_char ob '{';
    let is_first = ref true in
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"thing\":";
    (
      Yojson.Safe.write_string
    )
      ob x.thing;
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"other_thing\":";
    (
      Yojson.Safe.write_bool
    )
      ob x.other_thing;
    Bi_outbuf.add_char ob '}';
)
let string_of_a ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_a ob x;
  Bi_outbuf.contents ob
let read_a = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    Yojson.Safe.read_lcurl p lb;
    let field_thing = ref (None) in
    let field_other_thing = ref (None) in
    try
      Yojson.Safe.read_space p lb;
      Yojson.Safe.read_object_end lb;
      Yojson.Safe.read_space p lb;
      let f =
        fun s pos len ->
          if pos < 0 || len < 0 || pos + len > String.length s then
            invalid_arg "out-of-bounds substring position or length";
          match len with
            | 5 -> (
                if String.unsafe_get s pos = 't' && String.unsafe_get s (pos+1) = 'h' && String.unsafe_get s (pos+2) = 'i' && String.unsafe_get s (pos+3) = 'n' && String.unsafe_get s (pos+4) = 'g' then (
                  0
                )
                else (
                  -1
                )
              )
            | 11 -> (
                if String.unsafe_get s pos = 'o' && String.unsafe_get s (pos+1) = 't' && String.unsafe_get s (pos+2) = 'h' && String.unsafe_get s (pos+3) = 'e' && String.unsafe_get s (pos+4) = 'r' && String.unsafe_get s (pos+5) = '_' && String.unsafe_get s (pos+6) = 't' && String.unsafe_get s (pos+7) = 'h' && String.unsafe_get s (pos+8) = 'i' && String.unsafe_get s (pos+9) = 'n' && String.unsafe_get s (pos+10) = 'g' then (
                  1
                )
                else (
                  -1
                )
              )
            | _ -> (
                -1
              )
      in
      let i = Yojson.Safe.map_ident p f lb in
      Atdgen_runtime.Oj_run.read_until_field_value p lb;
      (
        match i with
          | 0 ->
            field_thing := (
              Some (
                (
                  Atdgen_runtime.Oj_run.read_string
                ) p lb
              )
            );
          | 1 ->
            field_other_thing := (
              Some (
                (
                  Atdgen_runtime.Oj_run.read_bool
                ) p lb
              )
            );
          | _ -> (
              Yojson.Safe.skip_json p lb
            )
      );
      while true do
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_object_sep p lb;
        Yojson.Safe.read_space p lb;
        let f =
          fun s pos len ->
            if pos < 0 || len < 0 || pos + len > String.length s then
              invalid_arg "out-of-bounds substring position or length";
            match len with
              | 5 -> (
                  if String.unsafe_get s pos = 't' && String.unsafe_get s (pos+1) = 'h' && String.unsafe_get s (pos+2) = 'i' && String.unsafe_get s (pos+3) = 'n' && String.unsafe_get s (pos+4) = 'g' then (
                    0
                  )
                  else (
                    -1
                  )
                )
              | 11 -> (
                  if String.unsafe_get s pos = 'o' && String.unsafe_get s (pos+1) = 't' && String.unsafe_get s (pos+2) = 'h' && String.unsafe_get s (pos+3) = 'e' && String.unsafe_get s (pos+4) = 'r' && String.unsafe_get s (pos+5) = '_' && String.unsafe_get s (pos+6) = 't' && String.unsafe_get s (pos+7) = 'h' && String.unsafe_get s (pos+8) = 'i' && String.unsafe_get s (pos+9) = 'n' && String.unsafe_get s (pos+10) = 'g' then (
                    1
                  )
                  else (
                    -1
                  )
                )
              | _ -> (
                  -1
                )
        in
        let i = Yojson.Safe.map_ident p f lb in
        Atdgen_runtime.Oj_run.read_until_field_value p lb;
        (
          match i with
            | 0 ->
              field_thing := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_string
                  ) p lb
                )
              );
            | 1 ->
              field_other_thing := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_bool
                  ) p lb
                )
              );
            | _ -> (
                Yojson.Safe.skip_json p lb
              )
        );
      done;
      assert false;
    with Yojson.End_of_object -> (
        (
          {
            thing = (match !field_thing with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "thing");
            other_thing = (match !field_other_thing with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "other_thing");
          }
         : a)
      )
)
let a_of_string s =
  read_a (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_adapted = (
  Atdgen_runtime.Oj_run.write_with_adapter Atdgen_runtime.Json_adapter.Type_field.restore (
    fun ob x ->
      match x with
        | `A x ->
          Bi_outbuf.add_string ob "[\"a\",";
          (
            write_a
          ) ob x;
          Bi_outbuf.add_char ob ']'
        | `B x ->
          Bi_outbuf.add_string ob "[\"b\",";
          (
            write_b
          ) ob x;
          Bi_outbuf.add_char ob ']'
  )
)
let string_of_adapted ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_adapted ob x;
  Bi_outbuf.contents ob
let read_adapted = (
  Atdgen_runtime.Oj_run.read_with_adapter Atdgen_runtime.Json_adapter.Type_field.normalize (
    fun p lb ->
      Yojson.Safe.read_space p lb;
      match Yojson.Safe.start_any_variant p lb with
        | `Edgy_bracket -> (
            match Yojson.Safe.read_ident p lb with
              | "a" ->
                Atdgen_runtime.Oj_run.read_until_field_value p lb;
                let x = (
                    read_a
                  ) p lb
                in
                Yojson.Safe.read_space p lb;
                Yojson.Safe.read_gt p lb;
                `A x
              | "b" ->
                Atdgen_runtime.Oj_run.read_until_field_value p lb;
                let x = (
                    read_b
                  ) p lb
                in
                Yojson.Safe.read_space p lb;
                Yojson.Safe.read_gt p lb;
                `B x
              | x ->
                Atdgen_runtime.Oj_run.invalid_variant_tag p x
          )
        | `Double_quote -> (
            match Yojson.Safe.finish_string p lb with
              | x ->
                Atdgen_runtime.Oj_run.invalid_variant_tag p x
          )
        | `Square_bracket -> (
            match Atdgen_runtime.Oj_run.read_string p lb with
              | "a" ->
                Yojson.Safe.read_space p lb;
                Yojson.Safe.read_comma p lb;
                Yojson.Safe.read_space p lb;
                let x = (
                    read_a
                  ) p lb
                in
                Yojson.Safe.read_space p lb;
                Yojson.Safe.read_rbr p lb;
                `A x
              | "b" ->
                Yojson.Safe.read_space p lb;
                Yojson.Safe.read_comma p lb;
                Yojson.Safe.read_space p lb;
                let x = (
                    read_b
                  ) p lb
                in
                Yojson.Safe.read_space p lb;
                Yojson.Safe.read_rbr p lb;
                `B x
              | x ->
                Atdgen_runtime.Oj_run.invalid_variant_tag p x
          )
  )
)
let adapted_of_string s =
  read_adapted (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
atd-2.1.0/atdgen/test/test3j_j.expected.mli000066400000000000000000000240321357165332000205410ustar00rootroot00000000000000(* Auto-generated from "test3j.atd" *)
[@@@ocaml.warning "-27-32-35-39"]

type rec_type = Test3j_t.rec_type = { more: rec_type list }

type unixtime_list = Test3j_t.unixtime_list

type json = Yojson.Safe.t

type tf_variant2 = Test3j_t.tf_variant2

type tf_variant = Test3j_t.tf_variant

type tf_record2 = Test3j_t.tf_record2 = {
  the_value2: tf_variant2;
  etc2: string
}

type tf_record = Test3j_t.tf_record = { the_value: tf_variant; etc: string }

type dyn = Yojson.Safe.t

type t = Test3j_t.t = { foo: int; bar: json; baz: dyn }

type sf_adapted = Test3j_t.sf_adapted

type sample_open_enum = Test3j_t.sample_open_enum

type sample_open_enums = Test3j_t.sample_open_enums

type patch = Test3j_t.patch = {
  patch1: int option option;
  patch2: int option option;
  patch3: int option option
}

type b = Test3j_t.b = { thing: int }

type a = Test3j_t.a = { thing: string; other_thing: bool }

type adapted = Test3j_t.adapted

val write_rec_type :
  Bi_outbuf.t -> rec_type -> unit
  (** Output a JSON value of type {!rec_type}. *)

val string_of_rec_type :
  ?len:int -> rec_type -> string
  (** Serialize a value of type {!rec_type}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_rec_type :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> rec_type
  (** Input JSON data of type {!rec_type}. *)

val rec_type_of_string :
  string -> rec_type
  (** Deserialize JSON data of type {!rec_type}. *)

val write_unixtime_list :
  Bi_outbuf.t -> unixtime_list -> unit
  (** Output a JSON value of type {!unixtime_list}. *)

val string_of_unixtime_list :
  ?len:int -> unixtime_list -> string
  (** Serialize a value of type {!unixtime_list}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_unixtime_list :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> unixtime_list
  (** Input JSON data of type {!unixtime_list}. *)

val unixtime_list_of_string :
  string -> unixtime_list
  (** Deserialize JSON data of type {!unixtime_list}. *)

val write_json :
  Bi_outbuf.t -> json -> unit
  (** Output a JSON value of type {!json}. *)

val string_of_json :
  ?len:int -> json -> string
  (** Serialize a value of type {!json}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_json :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> json
  (** Input JSON data of type {!json}. *)

val json_of_string :
  string -> json
  (** Deserialize JSON data of type {!json}. *)

val write_tf_variant2 :
  Bi_outbuf.t -> tf_variant2 -> unit
  (** Output a JSON value of type {!tf_variant2}. *)

val string_of_tf_variant2 :
  ?len:int -> tf_variant2 -> string
  (** Serialize a value of type {!tf_variant2}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_tf_variant2 :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> tf_variant2
  (** Input JSON data of type {!tf_variant2}. *)

val tf_variant2_of_string :
  string -> tf_variant2
  (** Deserialize JSON data of type {!tf_variant2}. *)

val write_tf_variant :
  Bi_outbuf.t -> tf_variant -> unit
  (** Output a JSON value of type {!tf_variant}. *)

val string_of_tf_variant :
  ?len:int -> tf_variant -> string
  (** Serialize a value of type {!tf_variant}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_tf_variant :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> tf_variant
  (** Input JSON data of type {!tf_variant}. *)

val tf_variant_of_string :
  string -> tf_variant
  (** Deserialize JSON data of type {!tf_variant}. *)

val write_tf_record2 :
  Bi_outbuf.t -> tf_record2 -> unit
  (** Output a JSON value of type {!tf_record2}. *)

val string_of_tf_record2 :
  ?len:int -> tf_record2 -> string
  (** Serialize a value of type {!tf_record2}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_tf_record2 :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> tf_record2
  (** Input JSON data of type {!tf_record2}. *)

val tf_record2_of_string :
  string -> tf_record2
  (** Deserialize JSON data of type {!tf_record2}. *)

val write_tf_record :
  Bi_outbuf.t -> tf_record -> unit
  (** Output a JSON value of type {!tf_record}. *)

val string_of_tf_record :
  ?len:int -> tf_record -> string
  (** Serialize a value of type {!tf_record}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_tf_record :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> tf_record
  (** Input JSON data of type {!tf_record}. *)

val tf_record_of_string :
  string -> tf_record
  (** Deserialize JSON data of type {!tf_record}. *)

val write_dyn :
  Bi_outbuf.t -> dyn -> unit
  (** Output a JSON value of type {!dyn}. *)

val string_of_dyn :
  ?len:int -> dyn -> string
  (** Serialize a value of type {!dyn}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_dyn :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> dyn
  (** Input JSON data of type {!dyn}. *)

val dyn_of_string :
  string -> dyn
  (** Deserialize JSON data of type {!dyn}. *)

val write_t :
  Bi_outbuf.t -> t -> unit
  (** Output a JSON value of type {!t}. *)

val string_of_t :
  ?len:int -> t -> string
  (** Serialize a value of type {!t}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_t :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> t
  (** Input JSON data of type {!t}. *)

val t_of_string :
  string -> t
  (** Deserialize JSON data of type {!t}. *)

val write_sf_adapted :
  Bi_outbuf.t -> sf_adapted -> unit
  (** Output a JSON value of type {!sf_adapted}. *)

val string_of_sf_adapted :
  ?len:int -> sf_adapted -> string
  (** Serialize a value of type {!sf_adapted}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_sf_adapted :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> sf_adapted
  (** Input JSON data of type {!sf_adapted}. *)

val sf_adapted_of_string :
  string -> sf_adapted
  (** Deserialize JSON data of type {!sf_adapted}. *)

val write_sample_open_enum :
  Bi_outbuf.t -> sample_open_enum -> unit
  (** Output a JSON value of type {!sample_open_enum}. *)

val string_of_sample_open_enum :
  ?len:int -> sample_open_enum -> string
  (** Serialize a value of type {!sample_open_enum}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_sample_open_enum :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> sample_open_enum
  (** Input JSON data of type {!sample_open_enum}. *)

val sample_open_enum_of_string :
  string -> sample_open_enum
  (** Deserialize JSON data of type {!sample_open_enum}. *)

val write_sample_open_enums :
  Bi_outbuf.t -> sample_open_enums -> unit
  (** Output a JSON value of type {!sample_open_enums}. *)

val string_of_sample_open_enums :
  ?len:int -> sample_open_enums -> string
  (** Serialize a value of type {!sample_open_enums}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_sample_open_enums :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> sample_open_enums
  (** Input JSON data of type {!sample_open_enums}. *)

val sample_open_enums_of_string :
  string -> sample_open_enums
  (** Deserialize JSON data of type {!sample_open_enums}. *)

val write_patch :
  Bi_outbuf.t -> patch -> unit
  (** Output a JSON value of type {!patch}. *)

val string_of_patch :
  ?len:int -> patch -> string
  (** Serialize a value of type {!patch}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_patch :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> patch
  (** Input JSON data of type {!patch}. *)

val patch_of_string :
  string -> patch
  (** Deserialize JSON data of type {!patch}. *)

val write_b :
  Bi_outbuf.t -> b -> unit
  (** Output a JSON value of type {!b}. *)

val string_of_b :
  ?len:int -> b -> string
  (** Serialize a value of type {!b}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_b :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> b
  (** Input JSON data of type {!b}. *)

val b_of_string :
  string -> b
  (** Deserialize JSON data of type {!b}. *)

val write_a :
  Bi_outbuf.t -> a -> unit
  (** Output a JSON value of type {!a}. *)

val string_of_a :
  ?len:int -> a -> string
  (** Serialize a value of type {!a}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_a :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> a
  (** Input JSON data of type {!a}. *)

val a_of_string :
  string -> a
  (** Deserialize JSON data of type {!a}. *)

val write_adapted :
  Bi_outbuf.t -> adapted -> unit
  (** Output a JSON value of type {!adapted}. *)

val string_of_adapted :
  ?len:int -> adapted -> string
  (** Serialize a value of type {!adapted}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_adapted :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> adapted
  (** Input JSON data of type {!adapted}. *)

val adapted_of_string :
  string -> adapted
  (** Deserialize JSON data of type {!adapted}. *)

atd-2.1.0/atdgen/test/test3j_t.expected.ml000066400000000000000000000015631357165332000204060ustar00rootroot00000000000000(* Auto-generated from "test3j.atd" *)
              [@@@ocaml.warning "-27-32-35-39"]

type rec_type = { more: rec_type list }

type unixtime_list = float list

type json = Yojson.Safe.t

type tf_variant2 = [
    `A of int
  | `B of int
  | `Unknown of (string * json option)
]

type tf_variant = [ `A of int | `B of int ]

type tf_record2 = { the_value2: tf_variant2; etc2: string }

type tf_record = { the_value: tf_variant; etc: string }

type dyn = Yojson.Safe.t

type t = { foo: int; bar: json; baz: dyn }

type sf_adapted = [ `A of bool | `B of int ]

type sample_open_enum = [ `Alpha | `Beta | `Other of string ]

type sample_open_enums = sample_open_enum list

type patch = {
  patch1: int option option;
  patch2: int option option;
  patch3: int option option
}

type b = { thing: int }

type a = { thing: string; other_thing: bool }

type adapted = [ `A of a | `B of b ]
atd-2.1.0/atdgen/test/test3j_t.expected.mli000066400000000000000000000015631357165332000205570ustar00rootroot00000000000000(* Auto-generated from "test3j.atd" *)
              [@@@ocaml.warning "-27-32-35-39"]

type rec_type = { more: rec_type list }

type unixtime_list = float list

type json = Yojson.Safe.t

type tf_variant2 = [
    `A of int
  | `B of int
  | `Unknown of (string * json option)
]

type tf_variant = [ `A of int | `B of int ]

type tf_record2 = { the_value2: tf_variant2; etc2: string }

type tf_record = { the_value: tf_variant; etc: string }

type dyn = Yojson.Safe.t

type t = { foo: int; bar: json; baz: dyn }

type sf_adapted = [ `A of bool | `B of int ]

type sample_open_enum = [ `Alpha | `Beta | `Other of string ]

type sample_open_enums = sample_open_enum list

type patch = {
  patch1: int option option;
  patch2: int option option;
  patch3: int option option
}

type b = { thing: int }

type a = { thing: string; other_thing: bool }

type adapted = [ `A of a | `B of b ]
atd-2.1.0/atdgen/test/test4.atd000066400000000000000000000003201357165332000162400ustar00rootroot00000000000000
type 'x abs1 = abstract

type 'x abs2 
              = abstract

type 'x abs3 
              = abstract
atd-2.1.0/atdgen/test/test5.atd000066400000000000000000000010211357165332000162400ustar00rootroot00000000000000(* Basic testing of -allow-name-overlap *)

type ab1 = {
  a : string;
  b : int;
}

type ab2 = {
  a : string;
  b : int;
}

type bca = {
  b : ab2 list;
  c : int list;
  a : float;
}

type cd1 = [
  | C of int
  | D of string
] 

type cd2 = [
  | C of float
  | D of bool
] 

type cde = [
  | C of int
  | D of cd1
  | E of cd2
]

type all = {
  a : ab1;
  b : ab2;
  c : bca list;
  d : cde list;
}

type contains_variant = {
  foo : string;
  bar : [ One | Two | Three of int ]
}
atd-2.1.0/atdgen/test/test_ambiguous_record.atd000066400000000000000000000002421357165332000215700ustar00rootroot00000000000000type ambiguous = {ambiguous:string;not_ambiguous1:int}

type ambiguous' = {ambiguous:string;not_ambiguous2:int}
   

atd-2.1.0/atdgen/test/test_ambiguous_record_j.expected.ml000066400000000000000000000303261357165332000235470ustar00rootroot00000000000000(* Auto-generated from "test_ambiguous_record.atd" *)
[@@@ocaml.warning "-27-32-35-39"]
open Test_ambiguous_record_t

let write_ambiguous' : _ -> ambiguous' -> _ = (
  Atdgen_runtime.Oj_run.write_with_adapter Json_adapters.Identity.restore (
    fun ob (x : ambiguous') ->
      Bi_outbuf.add_char ob '{';
      let is_first = ref true in
      if !is_first then
        is_first := false
      else
        Bi_outbuf.add_char ob ',';
      Bi_outbuf.add_string ob "\"ambiguous\":";
      (
        Yojson.Safe.write_string
      )
        ob x.ambiguous;
      if !is_first then
        is_first := false
      else
        Bi_outbuf.add_char ob ',';
      Bi_outbuf.add_string ob "\"not_ambiguous2\":";
      (
        Yojson.Safe.write_int
      )
        ob x.not_ambiguous2;
      Bi_outbuf.add_char ob '}';
  )
)
let string_of_ambiguous' ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_ambiguous' ob x;
  Bi_outbuf.contents ob
let read_ambiguous' = (
  Atdgen_runtime.Oj_run.read_with_adapter Json_adapters.Identity.normalize (
    fun p lb ->
      Yojson.Safe.read_space p lb;
      Yojson.Safe.read_lcurl p lb;
      let field_ambiguous = ref (None) in
      let field_not_ambiguous2 = ref (None) in
      try
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_object_end lb;
        Yojson.Safe.read_space p lb;
        let f =
          fun s pos len ->
            if pos < 0 || len < 0 || pos + len > String.length s then
              invalid_arg "out-of-bounds substring position or length";
            match len with
              | 9 -> (
                  if String.unsafe_get s pos = 'a' && String.unsafe_get s (pos+1) = 'm' && String.unsafe_get s (pos+2) = 'b' && String.unsafe_get s (pos+3) = 'i' && String.unsafe_get s (pos+4) = 'g' && String.unsafe_get s (pos+5) = 'u' && String.unsafe_get s (pos+6) = 'o' && String.unsafe_get s (pos+7) = 'u' && String.unsafe_get s (pos+8) = 's' then (
                    0
                  )
                  else (
                    -1
                  )
                )
              | 14 -> (
                  if String.unsafe_get s pos = 'n' && String.unsafe_get s (pos+1) = 'o' && String.unsafe_get s (pos+2) = 't' && String.unsafe_get s (pos+3) = '_' && String.unsafe_get s (pos+4) = 'a' && String.unsafe_get s (pos+5) = 'm' && String.unsafe_get s (pos+6) = 'b' && String.unsafe_get s (pos+7) = 'i' && String.unsafe_get s (pos+8) = 'g' && String.unsafe_get s (pos+9) = 'u' && String.unsafe_get s (pos+10) = 'o' && String.unsafe_get s (pos+11) = 'u' && String.unsafe_get s (pos+12) = 's' && String.unsafe_get s (pos+13) = '2' then (
                    1
                  )
                  else (
                    -1
                  )
                )
              | _ -> (
                  -1
                )
        in
        let i = Yojson.Safe.map_ident p f lb in
        Atdgen_runtime.Oj_run.read_until_field_value p lb;
        (
          match i with
            | 0 ->
              field_ambiguous := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_string
                  ) p lb
                )
              );
            | 1 ->
              field_not_ambiguous2 := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_int
                  ) p lb
                )
              );
            | _ -> (
                Yojson.Safe.skip_json p lb
              )
        );
        while true do
          Yojson.Safe.read_space p lb;
          Yojson.Safe.read_object_sep p lb;
          Yojson.Safe.read_space p lb;
          let f =
            fun s pos len ->
              if pos < 0 || len < 0 || pos + len > String.length s then
                invalid_arg "out-of-bounds substring position or length";
              match len with
                | 9 -> (
                    if String.unsafe_get s pos = 'a' && String.unsafe_get s (pos+1) = 'm' && String.unsafe_get s (pos+2) = 'b' && String.unsafe_get s (pos+3) = 'i' && String.unsafe_get s (pos+4) = 'g' && String.unsafe_get s (pos+5) = 'u' && String.unsafe_get s (pos+6) = 'o' && String.unsafe_get s (pos+7) = 'u' && String.unsafe_get s (pos+8) = 's' then (
                      0
                    )
                    else (
                      -1
                    )
                  )
                | 14 -> (
                    if String.unsafe_get s pos = 'n' && String.unsafe_get s (pos+1) = 'o' && String.unsafe_get s (pos+2) = 't' && String.unsafe_get s (pos+3) = '_' && String.unsafe_get s (pos+4) = 'a' && String.unsafe_get s (pos+5) = 'm' && String.unsafe_get s (pos+6) = 'b' && String.unsafe_get s (pos+7) = 'i' && String.unsafe_get s (pos+8) = 'g' && String.unsafe_get s (pos+9) = 'u' && String.unsafe_get s (pos+10) = 'o' && String.unsafe_get s (pos+11) = 'u' && String.unsafe_get s (pos+12) = 's' && String.unsafe_get s (pos+13) = '2' then (
                      1
                    )
                    else (
                      -1
                    )
                  )
                | _ -> (
                    -1
                  )
          in
          let i = Yojson.Safe.map_ident p f lb in
          Atdgen_runtime.Oj_run.read_until_field_value p lb;
          (
            match i with
              | 0 ->
                field_ambiguous := (
                  Some (
                    (
                      Atdgen_runtime.Oj_run.read_string
                    ) p lb
                  )
                );
              | 1 ->
                field_not_ambiguous2 := (
                  Some (
                    (
                      Atdgen_runtime.Oj_run.read_int
                    ) p lb
                  )
                );
              | _ -> (
                  Yojson.Safe.skip_json p lb
                )
          );
        done;
        assert false;
      with Yojson.End_of_object -> (
          (
            {
              ambiguous = (match !field_ambiguous with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "ambiguous");
              not_ambiguous2 = (match !field_not_ambiguous2 with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "not_ambiguous2");
            }
           : ambiguous')
        )
  )
)
let ambiguous'_of_string s =
  read_ambiguous' (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_ambiguous : _ -> ambiguous -> _ = (
  fun ob (x : ambiguous) ->
    Bi_outbuf.add_char ob '{';
    let is_first = ref true in
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"ambiguous\":";
    (
      Yojson.Safe.write_string
    )
      ob x.ambiguous;
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"not_ambiguous1\":";
    (
      Yojson.Safe.write_int
    )
      ob x.not_ambiguous1;
    Bi_outbuf.add_char ob '}';
)
let string_of_ambiguous ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_ambiguous ob x;
  Bi_outbuf.contents ob
let read_ambiguous = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    Yojson.Safe.read_lcurl p lb;
    let field_ambiguous = ref (None) in
    let field_not_ambiguous1 = ref (None) in
    try
      Yojson.Safe.read_space p lb;
      Yojson.Safe.read_object_end lb;
      Yojson.Safe.read_space p lb;
      let f =
        fun s pos len ->
          if pos < 0 || len < 0 || pos + len > String.length s then
            invalid_arg "out-of-bounds substring position or length";
          match len with
            | 9 -> (
                if String.unsafe_get s pos = 'a' && String.unsafe_get s (pos+1) = 'm' && String.unsafe_get s (pos+2) = 'b' && String.unsafe_get s (pos+3) = 'i' && String.unsafe_get s (pos+4) = 'g' && String.unsafe_get s (pos+5) = 'u' && String.unsafe_get s (pos+6) = 'o' && String.unsafe_get s (pos+7) = 'u' && String.unsafe_get s (pos+8) = 's' then (
                  0
                )
                else (
                  -1
                )
              )
            | 14 -> (
                if String.unsafe_get s pos = 'n' && String.unsafe_get s (pos+1) = 'o' && String.unsafe_get s (pos+2) = 't' && String.unsafe_get s (pos+3) = '_' && String.unsafe_get s (pos+4) = 'a' && String.unsafe_get s (pos+5) = 'm' && String.unsafe_get s (pos+6) = 'b' && String.unsafe_get s (pos+7) = 'i' && String.unsafe_get s (pos+8) = 'g' && String.unsafe_get s (pos+9) = 'u' && String.unsafe_get s (pos+10) = 'o' && String.unsafe_get s (pos+11) = 'u' && String.unsafe_get s (pos+12) = 's' && String.unsafe_get s (pos+13) = '1' then (
                  1
                )
                else (
                  -1
                )
              )
            | _ -> (
                -1
              )
      in
      let i = Yojson.Safe.map_ident p f lb in
      Atdgen_runtime.Oj_run.read_until_field_value p lb;
      (
        match i with
          | 0 ->
            field_ambiguous := (
              Some (
                (
                  Atdgen_runtime.Oj_run.read_string
                ) p lb
              )
            );
          | 1 ->
            field_not_ambiguous1 := (
              Some (
                (
                  Atdgen_runtime.Oj_run.read_int
                ) p lb
              )
            );
          | _ -> (
              Yojson.Safe.skip_json p lb
            )
      );
      while true do
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_object_sep p lb;
        Yojson.Safe.read_space p lb;
        let f =
          fun s pos len ->
            if pos < 0 || len < 0 || pos + len > String.length s then
              invalid_arg "out-of-bounds substring position or length";
            match len with
              | 9 -> (
                  if String.unsafe_get s pos = 'a' && String.unsafe_get s (pos+1) = 'm' && String.unsafe_get s (pos+2) = 'b' && String.unsafe_get s (pos+3) = 'i' && String.unsafe_get s (pos+4) = 'g' && String.unsafe_get s (pos+5) = 'u' && String.unsafe_get s (pos+6) = 'o' && String.unsafe_get s (pos+7) = 'u' && String.unsafe_get s (pos+8) = 's' then (
                    0
                  )
                  else (
                    -1
                  )
                )
              | 14 -> (
                  if String.unsafe_get s pos = 'n' && String.unsafe_get s (pos+1) = 'o' && String.unsafe_get s (pos+2) = 't' && String.unsafe_get s (pos+3) = '_' && String.unsafe_get s (pos+4) = 'a' && String.unsafe_get s (pos+5) = 'm' && String.unsafe_get s (pos+6) = 'b' && String.unsafe_get s (pos+7) = 'i' && String.unsafe_get s (pos+8) = 'g' && String.unsafe_get s (pos+9) = 'u' && String.unsafe_get s (pos+10) = 'o' && String.unsafe_get s (pos+11) = 'u' && String.unsafe_get s (pos+12) = 's' && String.unsafe_get s (pos+13) = '1' then (
                    1
                  )
                  else (
                    -1
                  )
                )
              | _ -> (
                  -1
                )
        in
        let i = Yojson.Safe.map_ident p f lb in
        Atdgen_runtime.Oj_run.read_until_field_value p lb;
        (
          match i with
            | 0 ->
              field_ambiguous := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_string
                  ) p lb
                )
              );
            | 1 ->
              field_not_ambiguous1 := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_int
                  ) p lb
                )
              );
            | _ -> (
                Yojson.Safe.skip_json p lb
              )
        );
      done;
      assert false;
    with Yojson.End_of_object -> (
        (
          {
            ambiguous = (match !field_ambiguous with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "ambiguous");
            not_ambiguous1 = (match !field_not_ambiguous1 with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "not_ambiguous1");
          }
         : ambiguous)
      )
)
let ambiguous_of_string s =
  read_ambiguous (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let create_ambiguous' 
  ~ambiguous
  ~not_ambiguous2
  () : ambiguous' =
  {
    ambiguous = ambiguous;
    not_ambiguous2 = not_ambiguous2;
  }
let create_ambiguous 
  ~ambiguous
  ~not_ambiguous1
  () : ambiguous =
  {
    ambiguous = ambiguous;
    not_ambiguous1 = not_ambiguous1;
  }
atd-2.1.0/atdgen/test/test_atdgen_main.ml000066400000000000000000000502051357165332000203510ustar00rootroot00000000000000open Atd.Import

let current_section = ref ""

let section =
  let first_section = ref true in
  fun name ->
    current_section := name;
    if !first_section then
      first_section := false

let errors = ref []

exception Failed

let fail () =
  errors := !current_section :: !errors;
  raise Failed

let check b =
  if not b then fail ()

let check_valid = function
  | None -> ()
  | Some _ -> fail ()

let check_invalid = function
  | None -> fail ()
  | Some _ -> ()

let expect_error f x =
  try
    ignore (f x);
    eprintf "Did not get expected error\n%!";
    fail ()
  with
    Atdgen_runtime.Ob_run.Error _
  | Atdgen_runtime.Oj_run.Error _ -> ()

let test_missing_record = {
  Test.b0 = 123;
  b1 = true
}

let test_extended_record = {
  Test.b0x = 55;
  b1x = false;
  b2x = "abc";
  b3x = Some "def";
  b4x = Some "ghi";
  b5x = 1.1;
}

let test_missing_tuple = (123, 4.56)


type internals1 = { int : int }
type internals2 = { float : float }

  (* Obj.magic 0.0, opaque_identity, and record fields

     Instead of using options (which may allocate), atdgen uses
     a default value for references that denote record fields that may
     not yet have been deserialized.

     For example, consider the following example in the test.ml
     generated code:

type extended = {
  b0x: int;
  b1x: bool;
  b2x: string;
  b3x: string option;
  b4x: string option;
  b5x: float
}

let get_extended_reader = (
  fun tag ->
    if tag <> 21 then Atdgen_runtime.Ob_run.read_error () else
      fun ib ->
        let field_b0x = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let field_b1x = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let field_b2x = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let field_b3x = ref (None) in
        let field_b4x = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let field_b5x = ref (0.5) in
        let bits0 = ref 0 in
        let len = Bi_vint.read_uvint ib in
        for i = 1 to len do
          match Bi_io.read_field_hashtag ib with
            | 21902 ->
              field_b0x := (
                (
                  Atdgen_runtime.Ob_run.read_int
                ) ib
              );
              bits0 := !bits0 lor 0x1;
            | 21903 ->
              field_b1x := (
                (
                  Atdgen_runtime.Ob_run.read_bool
                ) ib
              );
              bits0 := !bits0 lor 0x2;
           (* ... CODE ELIDED HERE ... *)
            | 21907 ->
              field_b5x := (
                (
                  Atdgen_runtime.Ob_run.read_float64
                ) ib
              );
            | _ -> Bi_io.skip ib
        done;
        if !bits0 <> 0xf then Atdgen_runtime.Ob_run.missing_fields
          [| !bits0 |] [| "b0"; "b1"; "b2"; "b4" |];
        (
          {
            b0x = !field_b0x;
            b1x = !field_b1x;
            b2x = !field_b2x;
            b3x = !field_b3x;
            b4x = !field_b4x;
            b5x = !field_b5x;
          }
         : extended)

     # Why Obj.magic?

     At code generation time we do not have a default
     value for the type of this field (we don't know what the type
     is), so we create one out of thin air with Obj.magic

     # Why 0.0?

     Atdgen does not run the type-checker, so it does not a-priori
     know if the field type is float (it may be a type alias of
     "float" or even depend on a functor parameter).

     If the type *is* float and the type-checker notices it
     statically, then it may allocate an unboxed float reference, and
     in particular unbox the default value passed at reference create
     time. If this default value was *not* a float, then the code could
     segfault. So in this case we must use a float value.

     If the type is *not* float, then passing a float value is still
     correct: the compiler will not try to unbox it, so a (word-sized)
     pointer will be stored in the reference.

     # Why Sys.opaque_identity?

     Starting from 4.03, the compiler is more clever at assuming
     things from values. When it sees the constant 0.0, it will infer
     in particular that the reference contains a float (so it may
     decide to unbox it!), etc. Notice that the compiler makes just
     the same assumptions about (Obj.magic 0.0) than about 0.0, the
     magic changes the type but not the value.

     Also in 4.03, the Sys.opaque_identity function was added in the
     Sys module; it is a compiler primitive of type ('a -> 'a) that
     prevents the compiler from assuming anything about its return value.

     In practice, using Sys.opaque_identity here avoids the segfault
     that happened without it on 4.03. Note that this may not be
     enough; in particular, (Sys.opaque_identity 0.0) is still
     recognizeably a value of "float" type to the compiler (only the
     value is unknown), so it would be legal for the compiler to still
     decide to unbox in the future!

     The long-term solution would be to stop using these unsafe
     Obj.magic and use an option type to store the reference fields in
     this case. This would be a more invasive change to the
     implementation.
  *)

let test_ocaml_internals () =
  section "ocaml internals";

  let opaque_identity =
    (* neat trick to fallback to just the identity if we are using
       a <4.03 version and Sys.opaque_identity is not available; found
       in
         https://github.com/LaurentMazare/tensorflow-ocaml/commit/111b4727cec992bab8bc67c22ccc8c31942ffbb2 *)
    let opaque_identity x = x in
    (* avoiding unused function warning and partial application warning. *)
    opaque_identity ();
    opaque_identity in

  let int = ref (Obj.magic (opaque_identity 0.0)) in
  Gc.compact ();
  int := 123;
  Gc.compact ();
  check ({ int = !int }.int = 123);

  let float = ref (Obj.magic 0) in
  Gc.compact ();
  float := 4.5;
  Gc.compact ();
  check ({ float = !float }.float = 4.5)

let test_biniou_missing_field () =
  section "biniou missing record fields";
  expect_error
    Test.extended_of_string (Test.string_of_base test_missing_record)

let test_biniou_missing_cell () =
  section "biniou missing tuple fields";
  expect_error
    Test.extended_tuple_of_string
    (Test.string_of_base_tuple test_missing_tuple)

let test_json_missing_field () =
  section "json missing record fields";
  expect_error
    Testj.extended_of_string (Testj.string_of_base test_missing_record)

let test_json_missing_cell () =
  section "json missing tuple fields";
  expect_error
    Testj.extended_tuple_of_string
    (Testj.string_of_base_tuple test_missing_tuple)

let test_json_extra_field_warning () =
  section "json extra field warning";
  ignore (Testj.base_of_string (Testj.string_of_extended test_extended_record))

let test_json_assoc_list () =
  section "json association list";
  let f l =
    let s = Testj.string_of_int_assoc_list l in
    check (Testj.int_assoc_list_of_string s = l)
  in
  f [];
  f [ ("a", 0) ];
  f [ ("a", 0); ("b", 1) ]

let test_json_assoc_array () =
  section "json association array";
  let f a =
    let s = Testj.string_of_int_assoc_array a in
    check (Testj.int_assoc_array_of_string s = a)
  in
  f [| |];
  f [| ("a", 0) |];
  f [| ("a", 0); ("b", 1) |]

let test_json_int_ocaml_float_gen of_json to_json kind () =
  section ("json ints derived from ocaml floats: " ^ kind);
  let l1 = [0.; 0.1; -0.1; 0.6; -0.6] in
  check (of_json (to_json l1) = [0.; 0.; 0.; 1.; -1.]);

  let l2 = [ 12345678901234567890.; -12345678901234567890. ] in
  let l2' = of_json (to_json l2) in
  List.iter2 (fun x x' -> assert (abs_float (1. -. x /. x') < 1e-15)) l2 l2';

  expect_error to_json [infinity];
  expect_error to_json [neg_infinity];
  expect_error to_json [nan]

let test_json_int_ocaml_float () =
  test_json_int_ocaml_float_gen
    Test3j_j.unixtime_list_of_string
    Test3j_j.string_of_unixtime_list
    "int " ();
  test_json_int_ocaml_float_gen
    Testj.unixtime_list_of_string
    Testj.string_of_unixtime_list
    "float " ()



let make_mixed_record_array n =
  Array.init n (
    fun i ->
      {
        Test.field0 = Some i;
        field1 = Some 0.555;
        field2 = Some "abcdefghijklmnopqrstuvwxyz";
        field3 = 12345678L;
        field4 = [| 1.23; 3.45; 4.56 |];
        field5 = None;
        field6 = None;
        field7 = `Case4 [ `Case1; `Case2 999; `Case3 "abcdefghij"; `Case4 [] ];
        field8 = [| "a"; "bc"; "def"; "ghij"; "klmno";
                    "pqrstu"; "vwxyz01"; "23456789" |];
        field9 = (
          1_000_000,
          0xff,
          '\xff',
          0xffff,
          0xffffffffl,
          0xffffffffffffffffL
        );
        field10 = true;
        field11 = false;
        field12 = [ (); () ];
        field13 = [ Some "abc"; None ];
        field14 = (2012, Some 3, None);
      }
  )

let make_mixed ~top_len ~tab_len ~ar_len =
  List.init top_len (fun _ ->
    (make_mixed_record_array tab_len, make_mixed_record_array ar_len)
  )


let test_correctness_data = {
  Test.x0 = Some 123;
  x1 = Some 1.23;
  x2 = make_mixed ~top_len:2 ~tab_len:2 ~ar_len:2;
  x3 = [
    {
      Test.field0 = Some 1234;
      field1 = Some 1e6;
      field2 = Some "Hello";
      field3 = 12345678L;
      field4 = [| 1.23; 3.45; 5.67 |];
      field5 = None;
      field6 = None;
      field7 = `Case4 [ `Case1; `Case2 999; `Case3 "abcdefghij"; `Case4 [] ];
      field8 = [| "abcdef"; "0123456789" |];
      field9 = (
        1_000_000,
        0xff,
        '\xff',
        0xffff,
        0xffffffffl,
        0xffffffffffffffffL
      );
      field10 = true;
      field11 = false;
      field12 = [ (); () ];
      field13 = [ Some "abc"; None ];
      field14 = (2012, Some 3, None);
    }
  ];
  x4 = 0x0807060504030201L;
}

let save file s =
  let oc = open_out_bin file in
  output_string oc s;
  close_out oc

let test_biniou_correctness () =
  section "biniou correctness";
  let x = test_correctness_data in
  let s = Test.string_of_test x in
  save "test.bin" s;
  let x' = Test.test_of_string s in
  let s' = Test.string_of_test x' in
  let x'' = Test.test_of_string s' in
  save "test-2.bin" s';
  if x <> x' then (
    eprintf "%s\n" (Bi_io.view s);
    eprintf "Data don't match\n";
    if s = s' then
      eprintf "Strings match\n"
    else
      eprintf "Strings don't match either\n";
    if x' = x'' then
      eprintf "2nd and 3rd generation data match\n"
    else
      eprintf "2nd and 3rd generation data differ\n";
    fail ()
  )

let test_json_correctness () =
  section "json correctness";
  let x = test_correctness_data in
  let s = Testj.string_of_test x in
  save "test.json" s;
  let x' = Testj.test_of_string s in
  let s' = Testj.string_of_test x' in
  let x'' = Testj.test_of_string s' in
  save "test-2.json" s';
  let std_x' = Testjstd.test_of_string s in
  let std_s' = Testjstd.string_of_test std_x' in
  let std_x'' = Testjstd.test_of_string std_s' in
  save "test-std.json" std_s';
  if x <> x' then (
    eprintf "%s\n" (Yojson.Safe.prettify s);
    eprintf "Data don't match\n";
    if s = s' then
      eprintf "Strings match\n"
    else
      eprintf "Strings don't match either\n";
    if x' = x'' then
      eprintf "2nd and 3rd generation data match\n"
    else
      eprintf "2nd and 3rd generation data differ\n";
    fail ()
  );
  check (std_x' = std_x'');
  assert (x = std_x')

let test_json_space () =
  section "json space";
  let s = Testj.string_of_test test_correctness_data in
  let pp = Yojson.Safe.prettify s in
  ignore (Testj.test_of_string pp)


let test_validators0 () =
  section "validators0";
  check_valid (Testv.validate_test [] test_correctness_data)

let test_validators1 () =
  section "validators1";
  let valid = (0, 1.) in
  let invalid = (1, 0.) in
  check_valid (Testv.validate_base_tuple [] valid);
  check_invalid (Testv.validate_base_tuple [] invalid);

  let x1 = {
    Test.b0x = 1;
    b1x = true;
    b2x = "abc";
    b3x = Some "def";
    b4x = Some "ghi";
    b5x = 1.1;
  }
  in
  check_invalid (Testv.validate_extended [] x1);
  let x2 = { x1 with Test.b1x = false } in
  check_valid (Testv.validate_extended [] x2);
  let x3 = { x2 with Test.b0x = -1 } in
  check_invalid (Testv.validate_extended [] x3)

let test_validators2 () =
  section "validators2";
  let v1 = `A in
  check_invalid (Testv.validate_p [] v1);
  let v2 = `B { Test.a = 0; b = true; c = `C } in
  check_valid (Testv.validate_p [] v2)

let test_validators3 () =
  section "validators3";
  let o = Some 0 in
  check_invalid (Testv.validate_option_validation [] o)

let test_validators4 () =
  section "validators4";
  let x = { Test.val2_x = { Test.val1_x = 0 };
            val2_y = Some { Test.val1_x = 1 } } in
  check_invalid (Testv.validate_val2 [] x)

let test_json_files () =
  section "json files";
  let x = Some 123 in
  let s = Atdgen_runtime.Util.Json.to_string Testj.write_intopt x in
  let x' = Atdgen_runtime.Util.Json.from_string Testj.read_intopt s in
  check (x = x');
  Atdgen_runtime.Util.Json.to_file Testj.write_intopt "test-json-files.json" x;
  let x'' = Atdgen_runtime.Util.Json.from_file Testj.read_intopt "test-json-files.json" in
  check (x = x'')

let test_json_streams () =
  section "json streams";
  let l = [ Some 1; None; Some 2; Some 3 ] in
  let s = Atdgen_runtime.Util.Json.list_to_string Testj.write_intopt l in
  let l' = Atdgen_runtime.Util.Json.list_from_string Testj.read_intopt s in
  check (l = l');
  Atdgen_runtime.Util.Json.list_to_file Testj.write_intopt "test-json-streams.json" l;
  let l'' =
    Atdgen_runtime.Util.Json.list_from_file Testj.read_intopt "test-json-streams.json"
  in
  check (l = l'')

let test_raw_json () =
  section "raw json";
  let x = { Test3j_t.foo = 12345;
            bar = `List [ `Int 12; `String "abc" ];
            baz = `Bool false }
  in
  let s = Test3j_j.string_of_t x in
  let x' = Test3j_j.t_of_string s in
  check (x = x')

let test_wrapping_ints () =
  section "ocaml wrapping - ints";
  let x = Test_lib.Natural.wrap 7 in
  let json = Testj.string_of_natural x in
  let x' = Testj.natural_of_string json in
  check (x = x');

  let biniou = Test.string_of_natural x in
  let x'' = Test.natural_of_string biniou in
  check (x = x'');

  try ignore (Testj.natural_of_string "-1"); check false
  with Failure _ -> ()

let test_double_wrapping () =
  section "ocaml wrapping - double wrapping";
  let x = Test_lib.Even_natural.wrap (Test_lib.Natural.wrap 10) in
  let json = Testj.string_of_even_natural x in
  let x' = Testj.even_natural_of_string json in
  check (x = x')

[@@@warning "-52"]
let test_wrapping_with_validation () =
  section "ocaml wrapping - with validation";
  let x = `Id "" in
  try ignore (Testv.validate_id [] x); check false
  with Failure "empty" -> ()

let test_ignored_wrap () =
  section "ocaml wrapping - wrap constructor without wrapper";
  let x = { Test.some_field = 0 } in
  try ignore (Testv.validate_no_real_wrap [] x); check false
  with Failure "passed" -> ()
[@@@warning "+52"]

let test_biniou_float32 () =
  section "check length of floats serialized as float32";
  let x = { Test.f32 = 1.23456789; Test.f64 = 1.98765432 } in
  let s = Test.string_of_floats x in
  let x' = Test.floats_of_string s in
  check Test.(abs_float (x.f32 -. x'.f32) < 1e-6);
  check (String.length s = 24)

let test_json_float_decimals () =
  section "print JSON floats with maximum number of decimal places";
  let x = {
    Testj.sqrt2_5 = sqrt 2.;
    small_2 = 0.000123456789;
    large_2 = 1234567890123.;
  } in
  let s = Testj.string_of_precision x in
  check (s = "{\"sqrt2_5\":1.4142,\"small_2\":0.00012,\"large_2\":1.2e+12}")

let test_patch () =
  section "read json record with null fields meaning (Some None)";
  let json = {| { "patch1": 1, "patch2": null } |} in
  let open Test3j_t in
  let x = Test3j_j.patch_of_string json in
  check (x.patch1 = Some (Some 1));
  check (x.patch2 = Some None);
  check (x.patch3 = None)

let test_adapted () =
  section "read and write a variant represented as a json object \
           with a `type` field";
  let json_a = {| {
    "type": "a",
    "thing": "abc",
    "other_thing": true,
    "ignored": 555
  } |} in
  let json_b =  {| {
    "thing": 123,
    "type": "b",
    "other_thing": true
  } |} in
  let expected_a = {|{"type":"a","thing":"abc","other_thing":true}|} in
  let expected_b = {|{"type":"b","thing":123}|} in
  let a = Test3j_j.adapted_of_string json_a in
  let b = Test3j_j.adapted_of_string json_b in
  let rewritten_a = Test3j_j.string_of_adapted a in
  let rewritten_b = Test3j_j.string_of_adapted b in
  check (expected_a = rewritten_a);
  check (expected_b = rewritten_b)

let test_one_field () =
  section "test variants represented with single-field json objects";
  let a_json = {| {"a": true} |} in
  let b_json = {| {"b": 17 } |} in
  let a = Test3j_j.sf_adapted_of_string a_json in
  let b = Test3j_j.sf_adapted_of_string b_json in
  check (a = `A true);
  check (b = `B 17);
  let a_json2 = Test3j_j.string_of_sf_adapted a in
  let b_json2 = Test3j_j.string_of_sf_adapted b in
  check (Test3j_j.sf_adapted_of_string a_json2 = a);
  check (Test3j_j.sf_adapted_of_string b_json2 = b)

let test_tag_field_emulation () =
  section "emulate the retired tag_field feature";
  let json_in = {| { "the_type": "a", "the_value": 123, "etc": "blah" } |} in
  let x = Test3j_j.tf_record_of_string json_in in
  check (x = { the_value = `A 123; etc = "blah" });
  let json_out = Test3j_j.string_of_tf_record x in
  let x2 = Test3j_j.tf_record_of_string json_out in
  check (x2 = x)

let test_tag_field_emulation_with_catchall () =
  section "emulate the retired tag_field feature, with a catch-all \
           for unknown tags";
  let json_in = {| { "the_type": "x", "the_value2": 3, "etc2": "blah" } |} in
  let x = Test3j_j.tf_record2_of_string json_in in
  check (x = { the_value2 = `Unknown ("x", Some (`Int 3)); etc2 = "blah" });
  let json_out = Test3j_j.string_of_tf_record2 x in
  let x2 = Test3j_j.tf_record2_of_string json_out in
  check (x2 = x)

let test_json_open_enum () =
  section "test ";
  let json_in = {| ["Alpha", "Gamma"] |} in
  let x = Test3j_j.sample_open_enums_of_string json_in in
  check (x = [`Alpha; `Other "Gamma"]);
  let json_out = Test3j_j.string_of_sample_open_enums x in
  let x2 = Test3j_j.sample_open_enums_of_string json_out in
  check (x2 = x)

let test_ambiguous_record () =
  section "test ambiguous record with json adapters";
  let json_in = {|{ambiguous:"x", not_ambiguous1:0}|} in
  let json_in' = {|{ambiguous:"x'", not_ambiguous2:1}|} in
  let x, x' =
    Test_ambiguous_record_j.ambiguous_of_string json_in,
    Test_ambiguous_record_j.ambiguous'_of_string json_in' in
  let json_out, json_out' =
    Test_ambiguous_record_j.string_of_ambiguous x,
    Test_ambiguous_record_j.string_of_ambiguous' x' in
  let x2, x2' =
    Test_ambiguous_record_j.ambiguous_of_string json_out,
    Test_ambiguous_record_j.ambiguous'_of_string json_out' in
  check ((x, x') = (x2, x2'))

let test_polymorphic_wrap () =
  section "test wrapping of polymorphic types";
  let json_in = {|["1", ["2"]]|} in
  let x =
    Test_polymorphic_wrap_j.t_of_string Yojson.Safe.read_string json_in in
  let json_out =
    Test_polymorphic_wrap_j.string_of_t Yojson.Safe.write_string x in
  let x2 =
    Test_polymorphic_wrap_j.t_of_string Yojson.Safe.read_string json_out in
  check (x = x2)

let all_tests = [
  test_ocaml_internals;
  test_biniou_missing_field;
  test_biniou_missing_cell;
  test_json_missing_field;
  test_json_missing_cell;
  test_json_extra_field_warning;
  test_json_assoc_list;
  test_json_assoc_array;
  test_json_int_ocaml_float;
  test_biniou_correctness;
  test_json_correctness;
  test_json_space;
  test_validators0;
  test_validators1;
  test_validators2;
  test_validators3;
  test_validators4;
  test_json_files;
  test_json_streams;
  test_raw_json;
  test_wrapping_ints;
  test_double_wrapping;
  test_wrapping_with_validation;
  test_ignored_wrap;
  test_biniou_float32;
  test_json_float_decimals;
  test_patch;
  test_adapted;
  test_one_field;
  test_tag_field_emulation;
  test_tag_field_emulation_with_catchall;
  test_json_open_enum;
  test_ambiguous_record;
]

(* TODO: use Alcotest to run the test suite. *)
let quality_test () =
  List.iter (fun f ->
    try f ()
    with Failed -> ())
    all_tests;
  match List.rev !errors with
  | [] ->
      ()
  | l ->
      eprintf "\nThe following tests failed:\n%s\n"
        (String.concat "\n" l);
      eprintf "*** FAILURE ***\n";
      exit 1

let () = quality_test ()





atd-2.1.0/atdgen/test/test_atdgen_type_conv.ml000066400000000000000000000007151357165332000214340ustar00rootroot00000000000000open Sexplib.Std

let my_record = Test_type_conv_t.({ fst=123; snd="testing" })

let cmrs : (float Test_type_conv_t.contains_my_record) list =
  let open Test_type_conv_t in
  [ `C1 123
  ; `C2 123.0
  ; `C3 my_record ]

let sexps =
  [my_record |> Test_type_conv_t.sexp_of_my_record] @
  (List.map (Test_type_conv_t.sexp_of_contains_my_record sexp_of_float) cmrs)

let () =
  sexps
  |> sexp_of_list (fun x -> x)
  |> Sexplib.Sexp.to_string
  |> print_endline
atd-2.1.0/atdgen/test/test_lib.ml000066400000000000000000000026701357165332000166540ustar00rootroot00000000000000type t = Foo of int

let fail _ = failwith "not implemented"

module Biniou =
struct
  type def = t
  let def_tag = 0
  let write_untagged_def _ : 'a -> unit = fail
  let write_def _ : 'a -> unit = fail
  let string_of_def = fail
  let get_def_reader _ = fail
  let read_def = fail
  let def_of_string = fail
end

module Json =
struct
  type def = t
  let write_def _ : 'a -> unit = fail
  let string_of_def = fail
  let read_def _ = fail
  let def_of_string = fail
end

module Natural :
sig
  type t = private int
  val wrap : int -> t
  val unwrap : t -> int
end =
struct
  type t = int
  let wrap x =
    if x < 0 then
      failwith ("Out of bounds number " ^ string_of_int x)
    else
      x
  let unwrap x = x
end

module Even_natural :
sig
  type t = private Natural.t
  val wrap : Natural.t -> t
  val unwrap : t -> Natural.t
end =
struct
  type t = Natural.t
  let wrap (x : Natural.t) =
    if (x :> int) mod 2 <> 0 then
      failwith ("Odd number " ^ string_of_int (x :> int))
    else
      x
  let unwrap x = x
end

module Tag_field_example =
  Atdgen_runtime.Json_adapter.Type_and_value_fields.Make (struct
    let type_field_name = "the_type"
    let value_field_name = "the_value"
    let known_tags = None
  end)

module Tag_field_with_catchall =
  Atdgen_runtime.Json_adapter.Type_and_value_fields.Make (struct
    let type_field_name = "the_type"
    let value_field_name = "the_value2"
    let known_tags = Some (["a";"b"], "Unknown")
  end)
atd-2.1.0/atdgen/test/test_polymorphic_wrap.atd000066400000000000000000000000651357165332000216400ustar00rootroot00000000000000type 'a t = 'a list wrap 
atd-2.1.0/atdgen/test/test_polymorphic_wrap_j.expected.ml000066400000000000000000000024021357165332000236060ustar00rootroot00000000000000(* Auto-generated from "test_polymorphic_wrap.atd" *)
[@@@ocaml.warning "-27-32-35-39"]

type 'a t = 'a Array_wrap.t

let write__1 write__a = (
  Atdgen_runtime.Oj_run.write_list (
    write__a
  )
)
let string_of__1 write__a ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__1 write__a ob x;
  Bi_outbuf.contents ob
let read__1 read__a = (
  Atdgen_runtime.Oj_run.read_list (
    read__a
  )
)
let _1_of_string read__a s =
  read__1 read__a (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__2 write__a = (
  fun ob x -> (
    let x = ( Array_wrap.unwrap ) x in (
      write__1 write__a
    ) ob x)
)
let string_of__2 write__a ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__2 write__a ob x;
  Bi_outbuf.contents ob
let read__2 read__a = (
  fun p lb ->
    let x = (
      read__1 read__a
    ) p lb in
    ( Array_wrap.wrap ) x
)
let _2_of_string read__a s =
  read__2 read__a (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_t write__a = (
  write__2 write__a
)
let string_of_t write__a ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_t write__a ob x;
  Bi_outbuf.contents ob
let read_t read__a = (
  read__2 read__a
)
let t_of_string read__a s =
  read_t read__a (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
atd-2.1.0/atdgen/test/test_polymorphic_wrap_t.expected.ml000066400000000000000000000002031357165332000236150ustar00rootroot00000000000000(* Auto-generated from "test_polymorphic_wrap.atd" *)
              [@@@ocaml.warning "-27-32-35-39"]

type 'a t = 'a Array_wrap.t
atd-2.1.0/atdgen/test/test_type_conv.atd000066400000000000000000000002441357165332000202470ustar00rootroot00000000000000

type my_record = {
  fst: int;
  snd: string;
}


type 'a contains_my_record = [
  | C1 of int
  | C2 of 'a
  | C3 of my_record
]
atd-2.1.0/atdgen/test/testj.expected.ml000066400000000000000000004411431357165332000200020ustar00rootroot00000000000000(* Auto-generated from "test.atd" *)
[@@@ocaml.warning "-27-32-35-39"]

(** This is just a test. *)

type test_variant = Test.test_variant

type ('x, 'y) poly = ('x, 'y) Test.poly = {
  fst: 'x list;
  snd: ('x, 'y) poly option
}

type 'a p' = 'a Test.p' =  A | Bb of 'a p' | Ccccc of 'a 

type p = Test.p

and r = Test.r = { a: int; mutable b: bool; c: p }

type validated_string_check = Test.validated_string_check

type validate_me = Test.validate_me

type val1 = Test.val1 = { val1_x: int }

type val2 = Test.val2 = { val2_x: val1; val2_y: val1 option }

type unixtime_list = Test.unixtime_list

type date = Test.date

type mixed_record = Test.mixed_record = {
  field0: int option;
  field1: float option;
  field2: string option;
  field3: Int64.t;
  field4: float Atdgen_runtime.Util.ocaml_array;
  field5: bool option;
  field6: string option;
  field7: test_variant;
  field8: string Atdgen_runtime.Util.ocaml_array;
  field9: (int * int * Char.t * int * Int32.t * Int64.t);
  field10: bool;
  field11: bool;
  field12: unit list;
  field13: string option list;
  field14: date
}

type mixed = Test.mixed

type test = Test.test = {
  x0: int option;
  x1: float option;
  x2: mixed;
  x3: mixed_record list;
  x4: Int64.t
}

type tup = Test.tup

type star_rating = Test.star_rating

type 'a generic = 'a Test.generic = { x294623: int }

type specialized = Test.specialized

type some_record = Test.some_record = { some_field: int }

type precision = Test.precision = {
  sqrt2_5: float;
  small_2: float;
  large_2: float
}

type p'' = Test.p''

type option_validation = Test.option_validation

type no_real_wrap = Test.no_real_wrap

type natural = Test.natural

type id = Test.id

type json_map = Test.json_map

type intopt = Test.intopt

type int_assoc_list = Test.int_assoc_list

type int_assoc_array = Test.int_assoc_array

type int8 = Test.int8

type int64 = Test.int64

type int32 = Test.int32

type hello = Test.hello

type floats = Test.floats = { f32: float; f64: float }

type extended_tuple = Test.extended_tuple

type extended = Test.extended = {
  b0x (*atd b0 *): int;
  b1x (*atd b1 *): bool;
  b2x (*atd b2 *): string;
  b3x (*atd b3 *): string option;
  b4x (*atd b4 *): string option;
  b5x (*atd b5 *): float
}

type even_natural = Test.even_natural

(**
  \}\}\}abc[def]ghi
  
{v
j  *  j
 k * k
  l*l
v}
  
{v
mno
v}
  
  [pqr]\{stu\}vwx
  
  yz
  
  [\} \[ \] \{v]
  
{v
\} [x] v\} \{v [ @ 
v}
*)
type def = Test_lib.Json.def

type char = Test.char

type base_tuple = Test.base_tuple

type base = Test.base = { b0: int; b1: bool }

type 'a array = 'a Test.array

type 'a abs3 = 'a Test.abs3

type 'a abs2 = 'a Test.abs2

type 'a abs1 = 'a Test.abs1

let write__19 write__a = (
  Atdgen_runtime.Oj_run.write_list (
    write__a
  )
)
let string_of__19 write__a ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__19 write__a ob x;
  Bi_outbuf.contents ob
let read__19 read__a = (
  Atdgen_runtime.Oj_run.read_list (
    read__a
  )
)
let _19_of_string read__a s =
  read__19 read__a (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let rec write_p' write__a : _ -> 'a p' -> _ = (
  fun ob x ->
    match x with
      | A -> Bi_outbuf.add_string ob "<\"A\">"
      | Bb x ->
        Bi_outbuf.add_string ob "<\"Bb\":";
        (
          write_p' write__a
        ) ob x;
        Bi_outbuf.add_char ob '>'
      | Ccccc x ->
        Bi_outbuf.add_string ob "<\"Ccccc\":";
        (
          write__a
        ) ob x;
        Bi_outbuf.add_char ob '>'
)
and string_of_p' write__a ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_p' write__a ob x;
  Bi_outbuf.contents ob
let rec read_p' read__a = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    match Yojson.Safe.start_any_variant p lb with
      | `Edgy_bracket -> (
          match Yojson.Safe.read_ident p lb with
            | "A" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              (A : 'a p')
            | "Bb" ->
              Atdgen_runtime.Oj_run.read_until_field_value p lb;
              let x = (
                  read_p' read__a
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              (Bb x : 'a p')
            | "Ccccc" ->
              Atdgen_runtime.Oj_run.read_until_field_value p lb;
              let x = (
                  read__a
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              (Ccccc x : 'a p')
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Double_quote -> (
          match Yojson.Safe.finish_string p lb with
            | "A" ->
              (A : 'a p')
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Square_bracket -> (
          match Atdgen_runtime.Oj_run.read_string p lb with
            | "Bb" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_comma p lb;
              Yojson.Safe.read_space p lb;
              let x = (
                  read_p' read__a
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_rbr p lb;
              (Bb x : 'a p')
            | "Ccccc" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_comma p lb;
              Yojson.Safe.read_space p lb;
              let x = (
                  read__a
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_rbr p lb;
              (Ccccc x : 'a p')
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
)
and p'_of_string read__a s =
  read_p' read__a (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let rec write_p = (
  fun ob x ->
    match x with
      | `A -> Bi_outbuf.add_string ob "<\"A\">"
      | `B x ->
        Bi_outbuf.add_string ob "<\"B\":";
        (
          write_r
        ) ob x;
        Bi_outbuf.add_char ob '>'
      | `C -> Bi_outbuf.add_string ob "<\"C\">"
)
and string_of_p ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_p ob x;
  Bi_outbuf.contents ob
and write_r : _ -> r -> _ = (
  fun ob (x : r) ->
    Bi_outbuf.add_char ob '{';
    let is_first = ref true in
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"a\":";
    (
      Yojson.Safe.write_int
    )
      ob x.a;
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"b\":";
    (
      Yojson.Safe.write_bool
    )
      ob x.b;
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"c\":";
    (
      write_p
    )
      ob x.c;
    Bi_outbuf.add_char ob '}';
)
and string_of_r ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_r ob x;
  Bi_outbuf.contents ob
let rec read_p = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    match Yojson.Safe.start_any_variant p lb with
      | `Edgy_bracket -> (
          match Yojson.Safe.read_ident p lb with
            | "A" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              `A
            | "B" ->
              Atdgen_runtime.Oj_run.read_until_field_value p lb;
              let x = (
                  read_r
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              `B x
            | "C" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              `C
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Double_quote -> (
          match Yojson.Safe.finish_string p lb with
            | "A" ->
              `A
            | "C" ->
              `C
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Square_bracket -> (
          match Atdgen_runtime.Oj_run.read_string p lb with
            | "B" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_comma p lb;
              Yojson.Safe.read_space p lb;
              let x = (
                  read_r
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_rbr p lb;
              `B x
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
)
and p_of_string s =
  read_p (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
and read_r = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    Yojson.Safe.read_lcurl p lb;
    let field_a = ref (None) in
    let field_b = ref (None) in
    let field_c = ref (None) in
    try
      Yojson.Safe.read_space p lb;
      Yojson.Safe.read_object_end lb;
      Yojson.Safe.read_space p lb;
      let f =
        fun s pos len ->
          if pos < 0 || len < 0 || pos + len > String.length s then
            invalid_arg "out-of-bounds substring position or length";
          if len = 1 then (
            match String.unsafe_get s pos with
              | 'a' -> (
                  0
                )
              | 'b' -> (
                  1
                )
              | 'c' -> (
                  2
                )
              | _ -> (
                  (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 25, characters 9-96" (String.sub s pos len); -1
                )
          )
          else (
            (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 25, characters 9-96" (String.sub s pos len); -1
          )
      in
      let i = Yojson.Safe.map_ident p f lb in
      Atdgen_runtime.Oj_run.read_until_field_value p lb;
      (
        match i with
          | 0 ->
            field_a := (
              Some (
                (
                  Atdgen_runtime.Oj_run.read_int
                ) p lb
              )
            );
          | 1 ->
            field_b := (
              Some (
                (
                  Atdgen_runtime.Oj_run.read_bool
                ) p lb
              )
            );
          | 2 ->
            field_c := (
              Some (
                (
                  read_p
                ) p lb
              )
            );
          | _ -> (
              Yojson.Safe.skip_json p lb
            )
      );
      while true do
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_object_sep p lb;
        Yojson.Safe.read_space p lb;
        let f =
          fun s pos len ->
            if pos < 0 || len < 0 || pos + len > String.length s then
              invalid_arg "out-of-bounds substring position or length";
            if len = 1 then (
              match String.unsafe_get s pos with
                | 'a' -> (
                    0
                  )
                | 'b' -> (
                    1
                  )
                | 'c' -> (
                    2
                  )
                | _ -> (
                    (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 25, characters 9-96" (String.sub s pos len); -1
                  )
            )
            else (
              (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 25, characters 9-96" (String.sub s pos len); -1
            )
        in
        let i = Yojson.Safe.map_ident p f lb in
        Atdgen_runtime.Oj_run.read_until_field_value p lb;
        (
          match i with
            | 0 ->
              field_a := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_int
                  ) p lb
                )
              );
            | 1 ->
              field_b := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_bool
                  ) p lb
                )
              );
            | 2 ->
              field_c := (
                Some (
                  (
                    read_p
                  ) p lb
                )
              );
            | _ -> (
                Yojson.Safe.skip_json p lb
              )
        );
      done;
      assert false;
    with Yojson.End_of_object -> (
        (
          {
            a = (match !field_a with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "a");
            b = (match !field_b with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "b");
            c = (match !field_c with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "c");
          }
         : r)
      )
)
and r_of_string s =
  read_r (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let rec write__20 write__a write__b ob x = (
  Atdgen_runtime.Oj_run.write_option (
    write_poly write__a write__b
  )
) ob x
and string_of__20 write__a write__b ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__20 write__a write__b ob x;
  Bi_outbuf.contents ob
and write_poly write__x write__y : _ -> ('x, 'y) poly -> _ = (
  fun ob (x : ('x, 'y) poly) ->
    Bi_outbuf.add_char ob '{';
    let is_first = ref true in
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"fst\":";
    (
      write__19 write__x
    )
      ob x.fst;
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"snd\":";
    (
      write__20 write__x write__y
    )
      ob x.snd;
    Bi_outbuf.add_char ob '}';
)
and string_of_poly write__x write__y ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_poly write__x write__y ob x;
  Bi_outbuf.contents ob
let rec read__20 read__a read__b = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    match Yojson.Safe.start_any_variant p lb with
      | `Edgy_bracket -> (
          match Yojson.Safe.read_ident p lb with
            | "None" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              (None : _ option)
            | "Some" ->
              Atdgen_runtime.Oj_run.read_until_field_value p lb;
              let x = (
                  read_poly read__a read__b
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              (Some x : _ option)
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Double_quote -> (
          match Yojson.Safe.finish_string p lb with
            | "None" ->
              (None : _ option)
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Square_bracket -> (
          match Atdgen_runtime.Oj_run.read_string p lb with
            | "Some" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_comma p lb;
              Yojson.Safe.read_space p lb;
              let x = (
                  read_poly read__a read__b
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_rbr p lb;
              (Some x : _ option)
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
)
and _20_of_string read__a read__b s =
  read__20 read__a read__b (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
and read_poly read__x read__y = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    Yojson.Safe.read_lcurl p lb;
    let field_fst = ref (None) in
    let field_snd = ref (None) in
    try
      Yojson.Safe.read_space p lb;
      Yojson.Safe.read_object_end lb;
      Yojson.Safe.read_space p lb;
      let f =
        fun s pos len ->
          if pos < 0 || len < 0 || pos + len > String.length s then
            invalid_arg "out-of-bounds substring position or length";
          if len = 3 then (
            match String.unsafe_get s pos with
              | 'f' -> (
                  if String.unsafe_get s (pos+1) = 's' && String.unsafe_get s (pos+2) = 't' then (
                    0
                  )
                  else (
                    (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 143, characters 21-71" (String.sub s pos len); -1
                  )
                )
              | 's' -> (
                  if String.unsafe_get s (pos+1) = 'n' && String.unsafe_get s (pos+2) = 'd' then (
                    1
                  )
                  else (
                    (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 143, characters 21-71" (String.sub s pos len); -1
                  )
                )
              | _ -> (
                  (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 143, characters 21-71" (String.sub s pos len); -1
                )
          )
          else (
            (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 143, characters 21-71" (String.sub s pos len); -1
          )
      in
      let i = Yojson.Safe.map_ident p f lb in
      Atdgen_runtime.Oj_run.read_until_field_value p lb;
      (
        match i with
          | 0 ->
            field_fst := (
              Some (
                (
                  read__19 read__x
                ) p lb
              )
            );
          | 1 ->
            field_snd := (
              Some (
                (
                  read__20 read__x read__y
                ) p lb
              )
            );
          | _ -> (
              Yojson.Safe.skip_json p lb
            )
      );
      while true do
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_object_sep p lb;
        Yojson.Safe.read_space p lb;
        let f =
          fun s pos len ->
            if pos < 0 || len < 0 || pos + len > String.length s then
              invalid_arg "out-of-bounds substring position or length";
            if len = 3 then (
              match String.unsafe_get s pos with
                | 'f' -> (
                    if String.unsafe_get s (pos+1) = 's' && String.unsafe_get s (pos+2) = 't' then (
                      0
                    )
                    else (
                      (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 143, characters 21-71" (String.sub s pos len); -1
                    )
                  )
                | 's' -> (
                    if String.unsafe_get s (pos+1) = 'n' && String.unsafe_get s (pos+2) = 'd' then (
                      1
                    )
                    else (
                      (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 143, characters 21-71" (String.sub s pos len); -1
                    )
                  )
                | _ -> (
                    (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 143, characters 21-71" (String.sub s pos len); -1
                  )
            )
            else (
              (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 143, characters 21-71" (String.sub s pos len); -1
            )
        in
        let i = Yojson.Safe.map_ident p f lb in
        Atdgen_runtime.Oj_run.read_until_field_value p lb;
        (
          match i with
            | 0 ->
              field_fst := (
                Some (
                  (
                    read__19 read__x
                  ) p lb
                )
              );
            | 1 ->
              field_snd := (
                Some (
                  (
                    read__20 read__x read__y
                  ) p lb
                )
              );
            | _ -> (
                Yojson.Safe.skip_json p lb
              )
        );
      done;
      assert false;
    with Yojson.End_of_object -> (
        (
          {
            fst = (match !field_fst with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "fst");
            snd = (match !field_snd with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "snd");
          }
         : ('x, 'y) poly)
      )
)
and poly_of_string read__x read__y s =
  read_poly read__x read__y (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let rec write__2 ob x = (
  Atdgen_runtime.Oj_run.write_list (
    write_test_variant
  )
) ob x
and string_of__2 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__2 ob x;
  Bi_outbuf.contents ob
and write_test_variant = (
  fun ob x ->
    match x with
      | `Case1 -> Bi_outbuf.add_string ob "<\"Case1\">"
      | `Case2 x ->
        Bi_outbuf.add_string ob "<\"Case2\":";
        (
          Yojson.Safe.write_int
        ) ob x;
        Bi_outbuf.add_char ob '>'
      | `Case3 x ->
        Bi_outbuf.add_string ob "<\"Case3\":";
        (
          Yojson.Safe.write_string
        ) ob x;
        Bi_outbuf.add_char ob '>'
      | `Case4 x ->
        Bi_outbuf.add_string ob "<\"Case4\":";
        (
          write__2
        ) ob x;
        Bi_outbuf.add_char ob '>'
)
and string_of_test_variant ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_test_variant ob x;
  Bi_outbuf.contents ob
let rec read__2 p lb = (
  Atdgen_runtime.Oj_run.read_list (
    read_test_variant
  )
) p lb
and _2_of_string s =
  read__2 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
and read_test_variant = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    match Yojson.Safe.start_any_variant p lb with
      | `Edgy_bracket -> (
          match Yojson.Safe.read_ident p lb with
            | "Case1" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              `Case1
            | "Case2" ->
              Atdgen_runtime.Oj_run.read_until_field_value p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_int
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              `Case2 x
            | "Case3" ->
              Atdgen_runtime.Oj_run.read_until_field_value p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_string
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              `Case3 x
            | "Case4" ->
              Atdgen_runtime.Oj_run.read_until_field_value p lb;
              let x = (
                  read__2
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              `Case4 x
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Double_quote -> (
          match Yojson.Safe.finish_string p lb with
            | "Case1" ->
              `Case1
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Square_bracket -> (
          match Atdgen_runtime.Oj_run.read_string p lb with
            | "Case2" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_comma p lb;
              Yojson.Safe.read_space p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_int
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_rbr p lb;
              `Case2 x
            | "Case3" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_comma p lb;
              Yojson.Safe.read_space p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_string
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_rbr p lb;
              `Case3 x
            | "Case4" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_comma p lb;
              Yojson.Safe.read_space p lb;
              let x = (
                  read__2
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_rbr p lb;
              `Case4 x
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
)
and test_variant_of_string s =
  read_test_variant (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let rec write__1 : _ -> _ p' -> _ = (
  fun ob x ->
    match x with
      | A -> Bi_outbuf.add_string ob "<\"A\">"
      | Bb x ->
        Bi_outbuf.add_string ob "<\"Bb\":";
        (
          write__1
        ) ob x;
        Bi_outbuf.add_char ob '>'
      | Ccccc x ->
        Bi_outbuf.add_string ob "<\"Ccccc\":";
        (
          Yojson.Safe.write_int
        ) ob x;
        Bi_outbuf.add_char ob '>'
)
and string_of__1 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__1 ob x;
  Bi_outbuf.contents ob
let rec read__1 = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    match Yojson.Safe.start_any_variant p lb with
      | `Edgy_bracket -> (
          match Yojson.Safe.read_ident p lb with
            | "A" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              (A : _ p')
            | "Bb" ->
              Atdgen_runtime.Oj_run.read_until_field_value p lb;
              let x = (
                  read__1
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              (Bb x : _ p')
            | "Ccccc" ->
              Atdgen_runtime.Oj_run.read_until_field_value p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_int
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              (Ccccc x : _ p')
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Double_quote -> (
          match Yojson.Safe.finish_string p lb with
            | "A" ->
              (A : _ p')
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Square_bracket -> (
          match Atdgen_runtime.Oj_run.read_string p lb with
            | "Bb" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_comma p lb;
              Yojson.Safe.read_space p lb;
              let x = (
                  read__1
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_rbr p lb;
              (Bb x : _ p')
            | "Ccccc" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_comma p lb;
              Yojson.Safe.read_space p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_int
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_rbr p lb;
              (Ccccc x : _ p')
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
)
and _1_of_string s =
  read__1 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_validated_string_check = (
  Yojson.Safe.write_string
)
let string_of_validated_string_check ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_validated_string_check ob x;
  Bi_outbuf.contents ob
let read_validated_string_check = (
  Atdgen_runtime.Oj_run.read_string
)
let validated_string_check_of_string s =
  read_validated_string_check (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__31 = (
  Atdgen_runtime.Oj_run.write_list (
    Yojson.Safe.write_string
  )
)
let string_of__31 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__31 ob x;
  Bi_outbuf.contents ob
let read__31 = (
  Atdgen_runtime.Oj_run.read_list (
    Atdgen_runtime.Oj_run.read_string
  )
)
let _31_of_string s =
  read__31 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_validate_me = (
  write__31
)
let string_of_validate_me ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_validate_me ob x;
  Bi_outbuf.contents ob
let read_validate_me = (
  read__31
)
let validate_me_of_string s =
  read_validate_me (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_val1 : _ -> val1 -> _ = (
  fun ob (x : val1) ->
    Bi_outbuf.add_char ob '{';
    let is_first = ref true in
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"val1_x\":";
    (
      Yojson.Safe.write_int
    )
      ob x.val1_x;
    Bi_outbuf.add_char ob '}';
)
let string_of_val1 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_val1 ob x;
  Bi_outbuf.contents ob
let read_val1 = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    Yojson.Safe.read_lcurl p lb;
    let field_val1_x = ref (None) in
    try
      Yojson.Safe.read_space p lb;
      Yojson.Safe.read_object_end lb;
      Yojson.Safe.read_space p lb;
      let f =
        fun s pos len ->
          if pos < 0 || len < 0 || pos + len > String.length s then
            invalid_arg "out-of-bounds substring position or length";
          if len = 6 && String.unsafe_get s pos = 'v' && String.unsafe_get s (pos+1) = 'a' && String.unsafe_get s (pos+2) = 'l' && String.unsafe_get s (pos+3) = '1' && String.unsafe_get s (pos+4) = '_' && String.unsafe_get s (pos+5) = 'x' then (
            0
          )
          else (
            (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 118, characters 12-161" (String.sub s pos len); -1
          )
      in
      let i = Yojson.Safe.map_ident p f lb in
      Atdgen_runtime.Oj_run.read_until_field_value p lb;
      (
        match i with
          | 0 ->
            field_val1_x := (
              Some (
                (
                  Atdgen_runtime.Oj_run.read_int
                ) p lb
              )
            );
          | _ -> (
              Yojson.Safe.skip_json p lb
            )
      );
      while true do
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_object_sep p lb;
        Yojson.Safe.read_space p lb;
        let f =
          fun s pos len ->
            if pos < 0 || len < 0 || pos + len > String.length s then
              invalid_arg "out-of-bounds substring position or length";
            if len = 6 && String.unsafe_get s pos = 'v' && String.unsafe_get s (pos+1) = 'a' && String.unsafe_get s (pos+2) = 'l' && String.unsafe_get s (pos+3) = '1' && String.unsafe_get s (pos+4) = '_' && String.unsafe_get s (pos+5) = 'x' then (
              0
            )
            else (
              (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 118, characters 12-161" (String.sub s pos len); -1
            )
        in
        let i = Yojson.Safe.map_ident p f lb in
        Atdgen_runtime.Oj_run.read_until_field_value p lb;
        (
          match i with
            | 0 ->
              field_val1_x := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_int
                  ) p lb
                )
              );
            | _ -> (
                Yojson.Safe.skip_json p lb
              )
        );
      done;
      assert false;
    with Yojson.End_of_object -> (
        (
          {
            val1_x = (match !field_val1_x with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "val1_x");
          }
         : val1)
      )
)
let val1_of_string s =
  read_val1 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__16 = (
  Atdgen_runtime.Oj_run.write_option (
    write_val1
  )
)
let string_of__16 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__16 ob x;
  Bi_outbuf.contents ob
let read__16 = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    match Yojson.Safe.start_any_variant p lb with
      | `Edgy_bracket -> (
          match Yojson.Safe.read_ident p lb with
            | "None" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              (None : _ option)
            | "Some" ->
              Atdgen_runtime.Oj_run.read_until_field_value p lb;
              let x = (
                  read_val1
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              (Some x : _ option)
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Double_quote -> (
          match Yojson.Safe.finish_string p lb with
            | "None" ->
              (None : _ option)
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Square_bracket -> (
          match Atdgen_runtime.Oj_run.read_string p lb with
            | "Some" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_comma p lb;
              Yojson.Safe.read_space p lb;
              let x = (
                  read_val1
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_rbr p lb;
              (Some x : _ option)
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
)
let _16_of_string s =
  read__16 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_val2 : _ -> val2 -> _ = (
  fun ob (x : val2) ->
    Bi_outbuf.add_char ob '{';
    let is_first = ref true in
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"val2_x\":";
    (
      write_val1
    )
      ob x.val2_x;
    (match x.val2_y with None -> () | Some x ->
      if !is_first then
        is_first := false
      else
        Bi_outbuf.add_char ob ',';
      Bi_outbuf.add_string ob "\"val2_y\":";
      (
        write_val1
      )
        ob x;
    );
    Bi_outbuf.add_char ob '}';
)
let string_of_val2 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_val2 ob x;
  Bi_outbuf.contents ob
let read_val2 = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    Yojson.Safe.read_lcurl p lb;
    let field_val2_x = ref (None) in
    let field_val2_y = ref (None) in
    try
      Yojson.Safe.read_space p lb;
      Yojson.Safe.read_object_end lb;
      Yojson.Safe.read_space p lb;
      let f =
        fun s pos len ->
          if pos < 0 || len < 0 || pos + len > String.length s then
            invalid_arg "out-of-bounds substring position or length";
          if len = 6 && String.unsafe_get s pos = 'v' && String.unsafe_get s (pos+1) = 'a' && String.unsafe_get s (pos+2) = 'l' && String.unsafe_get s (pos+3) = '2' && String.unsafe_get s (pos+4) = '_' then (
            match String.unsafe_get s (pos+5) with
              | 'x' -> (
                  0
                )
              | 'y' -> (
                  1
                )
              | _ -> (
                  (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 121, characters 12-57" (String.sub s pos len); -1
                )
          )
          else (
            (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 121, characters 12-57" (String.sub s pos len); -1
          )
      in
      let i = Yojson.Safe.map_ident p f lb in
      Atdgen_runtime.Oj_run.read_until_field_value p lb;
      (
        match i with
          | 0 ->
            field_val2_x := (
              Some (
                (
                  read_val1
                ) p lb
              )
            );
          | 1 ->
            if not (Yojson.Safe.read_null_if_possible p lb) then (
              field_val2_y := (
                Some (
                  (
                    read_val1
                  ) p lb
                )
              );
            )
          | _ -> (
              Yojson.Safe.skip_json p lb
            )
      );
      while true do
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_object_sep p lb;
        Yojson.Safe.read_space p lb;
        let f =
          fun s pos len ->
            if pos < 0 || len < 0 || pos + len > String.length s then
              invalid_arg "out-of-bounds substring position or length";
            if len = 6 && String.unsafe_get s pos = 'v' && String.unsafe_get s (pos+1) = 'a' && String.unsafe_get s (pos+2) = 'l' && String.unsafe_get s (pos+3) = '2' && String.unsafe_get s (pos+4) = '_' then (
              match String.unsafe_get s (pos+5) with
                | 'x' -> (
                    0
                  )
                | 'y' -> (
                    1
                  )
                | _ -> (
                    (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 121, characters 12-57" (String.sub s pos len); -1
                  )
            )
            else (
              (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 121, characters 12-57" (String.sub s pos len); -1
            )
        in
        let i = Yojson.Safe.map_ident p f lb in
        Atdgen_runtime.Oj_run.read_until_field_value p lb;
        (
          match i with
            | 0 ->
              field_val2_x := (
                Some (
                  (
                    read_val1
                  ) p lb
                )
              );
            | 1 ->
              if not (Yojson.Safe.read_null_if_possible p lb) then (
                field_val2_y := (
                  Some (
                    (
                      read_val1
                    ) p lb
                  )
                );
              )
            | _ -> (
                Yojson.Safe.skip_json p lb
              )
        );
      done;
      assert false;
    with Yojson.End_of_object -> (
        (
          {
            val2_x = (match !field_val2_x with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "val2_x");
            val2_y = !field_val2_y;
          }
         : val2)
      )
)
let val2_of_string s =
  read_val2 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__29 = (
  Atdgen_runtime.Oj_run.write_list (
    Atdgen_runtime.Oj_run.write_float_as_int
  )
)
let string_of__29 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__29 ob x;
  Bi_outbuf.contents ob
let read__29 = (
  Atdgen_runtime.Oj_run.read_list (
    Atdgen_runtime.Oj_run.read_number
  )
)
let _29_of_string s =
  read__29 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_unixtime_list = (
  write__29
)
let string_of_unixtime_list ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_unixtime_list ob x;
  Bi_outbuf.contents ob
let read_unixtime_list = (
  read__29
)
let unixtime_list_of_string s =
  read_unixtime_list (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__3 = (
  Atdgen_runtime.Oj_run.write_nullable (
    Yojson.Safe.write_int
  )
)
let string_of__3 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__3 ob x;
  Bi_outbuf.contents ob
let read__3 = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    (if Yojson.Safe.read_null_if_possible p lb then None
    else Some ((
      Atdgen_runtime.Oj_run.read_int
    ) p lb) : _ option)
)
let _3_of_string s =
  read__3 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_date = (
  fun ob x ->
    Bi_outbuf.add_char ob '(';
    (let x, _, _ = x in
    (
      Yojson.Safe.write_int
    ) ob x
    );
    Bi_outbuf.add_char ob ',';
    (let _, x, _ = x in
    (
      write__3
    ) ob x
    );
    Bi_outbuf.add_char ob ',';
    (let _, _, x = x in
    (
      write__3
    ) ob x
    );
    Bi_outbuf.add_char ob ')';
)
let string_of_date ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_date ob x;
  Bi_outbuf.contents ob
let read_date = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    let std_tuple = Yojson.Safe.start_any_tuple p lb in
    let len = ref 0 in
    let end_of_tuple = ref false in
    (try
      let x0 =
        let x =
          (
            Atdgen_runtime.Oj_run.read_int
          ) p lb
        in
        incr len;
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_tuple_sep2 p std_tuple lb;
        x
      in
      let x1 =
        let x =
          (
            read__3
          ) p lb
        in
        incr len;
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_tuple_sep2 p std_tuple lb;
        x
      in
      let x2 =
        let x =
          (
            read__3
          ) p lb
        in
        incr len;
        (try
          Yojson.Safe.read_space p lb;
          Yojson.Safe.read_tuple_sep2 p std_tuple lb;
        with Yojson.End_of_tuple -> end_of_tuple := true);
        x
      in
      if not !end_of_tuple then (
        try
          while true do
            Yojson.Safe.skip_json p lb;
            Yojson.Safe.read_space p lb;
            Yojson.Safe.read_tuple_sep2 p std_tuple lb;
          done
        with Yojson.End_of_tuple -> ()
      );
      (x0, x1, x2)
    with Yojson.End_of_tuple ->
      Atdgen_runtime.Oj_run.missing_tuple_fields p !len [ 0; 1; 2 ]);
)
let date_of_string s =
  read_date (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__9 = (
  Atdgen_runtime.Oj_run.write_array (
    Yojson.Safe.write_string
  )
)
let string_of__9 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__9 ob x;
  Bi_outbuf.contents ob
let read__9 = (
  Atdgen_runtime.Oj_run.read_array (
    Atdgen_runtime.Oj_run.read_string
  )
)
let _9_of_string s =
  read__9 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__8 = (
  Atdgen_runtime.Oj_run.write_option (
    Yojson.Safe.write_bool
  )
)
let string_of__8 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__8 ob x;
  Bi_outbuf.contents ob
let read__8 = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    match Yojson.Safe.start_any_variant p lb with
      | `Edgy_bracket -> (
          match Yojson.Safe.read_ident p lb with
            | "None" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              (None : _ option)
            | "Some" ->
              Atdgen_runtime.Oj_run.read_until_field_value p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_bool
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              (Some x : _ option)
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Double_quote -> (
          match Yojson.Safe.finish_string p lb with
            | "None" ->
              (None : _ option)
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Square_bracket -> (
          match Atdgen_runtime.Oj_run.read_string p lb with
            | "Some" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_comma p lb;
              Yojson.Safe.read_space p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_bool
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_rbr p lb;
              (Some x : _ option)
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
)
let _8_of_string s =
  read__8 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__7 = (
  Atdgen_runtime.Oj_run.write_array (
    Yojson.Safe.write_float
  )
)
let string_of__7 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__7 ob x;
  Bi_outbuf.contents ob
let read__7 = (
  Atdgen_runtime.Oj_run.read_array (
    Atdgen_runtime.Oj_run.read_number
  )
)
let _7_of_string s =
  read__7 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__6 = (
  Atdgen_runtime.Oj_run.write_option (
    Yojson.Safe.write_string
  )
)
let string_of__6 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__6 ob x;
  Bi_outbuf.contents ob
let read__6 = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    match Yojson.Safe.start_any_variant p lb with
      | `Edgy_bracket -> (
          match Yojson.Safe.read_ident p lb with
            | "None" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              (None : _ option)
            | "Some" ->
              Atdgen_runtime.Oj_run.read_until_field_value p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_string
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              (Some x : _ option)
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Double_quote -> (
          match Yojson.Safe.finish_string p lb with
            | "None" ->
              (None : _ option)
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Square_bracket -> (
          match Atdgen_runtime.Oj_run.read_string p lb with
            | "Some" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_comma p lb;
              Yojson.Safe.read_space p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_string
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_rbr p lb;
              (Some x : _ option)
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
)
let _6_of_string s =
  read__6 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__5 = (
  Atdgen_runtime.Oj_run.write_option (
    Yojson.Safe.write_float
  )
)
let string_of__5 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__5 ob x;
  Bi_outbuf.contents ob
let read__5 = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    match Yojson.Safe.start_any_variant p lb with
      | `Edgy_bracket -> (
          match Yojson.Safe.read_ident p lb with
            | "None" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              (None : _ option)
            | "Some" ->
              Atdgen_runtime.Oj_run.read_until_field_value p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_number
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              (Some x : _ option)
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Double_quote -> (
          match Yojson.Safe.finish_string p lb with
            | "None" ->
              (None : _ option)
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Square_bracket -> (
          match Atdgen_runtime.Oj_run.read_string p lb with
            | "Some" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_comma p lb;
              Yojson.Safe.read_space p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_number
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_rbr p lb;
              (Some x : _ option)
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
)
let _5_of_string s =
  read__5 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__4 = (
  Atdgen_runtime.Oj_run.write_option (
    Yojson.Safe.write_int
  )
)
let string_of__4 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__4 ob x;
  Bi_outbuf.contents ob
let read__4 = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    match Yojson.Safe.start_any_variant p lb with
      | `Edgy_bracket -> (
          match Yojson.Safe.read_ident p lb with
            | "None" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              (None : _ option)
            | "Some" ->
              Atdgen_runtime.Oj_run.read_until_field_value p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_int
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              (Some x : _ option)
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Double_quote -> (
          match Yojson.Safe.finish_string p lb with
            | "None" ->
              (None : _ option)
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Square_bracket -> (
          match Atdgen_runtime.Oj_run.read_string p lb with
            | "Some" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_comma p lb;
              Yojson.Safe.read_space p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_int
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_rbr p lb;
              (Some x : _ option)
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
)
let _4_of_string s =
  read__4 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__11 = (
  Atdgen_runtime.Oj_run.write_list (
    write__6
  )
)
let string_of__11 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__11 ob x;
  Bi_outbuf.contents ob
let read__11 = (
  Atdgen_runtime.Oj_run.read_list (
    read__6
  )
)
let _11_of_string s =
  read__11 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__10 = (
  Atdgen_runtime.Oj_run.write_list (
    Yojson.Safe.write_null
  )
)
let string_of__10 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__10 ob x;
  Bi_outbuf.contents ob
let read__10 = (
  Atdgen_runtime.Oj_run.read_list (
    Atdgen_runtime.Oj_run.read_null
  )
)
let _10_of_string s =
  read__10 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_mixed_record : _ -> mixed_record -> _ = (
  fun ob (x : mixed_record) ->
    Bi_outbuf.add_char ob '{';
    let is_first = ref true in
    (match x.field0 with None -> () | Some x ->
      if !is_first then
        is_first := false
      else
        Bi_outbuf.add_char ob ',';
      Bi_outbuf.add_string ob "\"field0\":";
      (
        Yojson.Safe.write_int
      )
        ob x;
    );
    (match x.field1 with None -> () | Some x ->
      if !is_first then
        is_first := false
      else
        Bi_outbuf.add_char ob ',';
      Bi_outbuf.add_string ob "\"field1\":";
      (
        Yojson.Safe.write_float
      )
        ob x;
    );
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"field2\":";
    (
      write__6
    )
      ob x.field2;
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"field3\":";
    (
      Atdgen_runtime.Oj_run.write_int64
    )
      ob x.field3;
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"field4\":";
    (
      write__7
    )
      ob x.field4;
    (match x.field5 with None -> () | Some x ->
      if !is_first then
        is_first := false
      else
        Bi_outbuf.add_char ob ',';
      Bi_outbuf.add_string ob "\"field5\":";
      (
        Yojson.Safe.write_bool
      )
        ob x;
    );
    (match x.field6 with None -> () | Some x ->
      if !is_first then
        is_first := false
      else
        Bi_outbuf.add_char ob ',';
      Bi_outbuf.add_string ob "\"field6\":";
      (
        Yojson.Safe.write_string
      )
        ob x;
    );
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"field7\":";
    (
      write_test_variant
    )
      ob x.field7;
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"field8\":";
    (
      write__9
    )
      ob x.field8;
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"field9\":";
    (
      fun ob x ->
        Bi_outbuf.add_char ob '(';
        (let x, _, _, _, _, _ = x in
        (
          Yojson.Safe.write_int
        ) ob x
        );
        Bi_outbuf.add_char ob ',';
        (let _, x, _, _, _, _ = x in
        (
          Yojson.Safe.write_int
        ) ob x
        );
        Bi_outbuf.add_char ob ',';
        (let _, _, x, _, _, _ = x in
        (
          Atdgen_runtime.Oj_run.write_int8
        ) ob x
        );
        Bi_outbuf.add_char ob ',';
        (let _, _, _, x, _, _ = x in
        (
          Yojson.Safe.write_int
        ) ob x
        );
        Bi_outbuf.add_char ob ',';
        (let _, _, _, _, x, _ = x in
        (
          Atdgen_runtime.Oj_run.write_int32
        ) ob x
        );
        Bi_outbuf.add_char ob ',';
        (let _, _, _, _, _, x = x in
        (
          Atdgen_runtime.Oj_run.write_int64
        ) ob x
        );
        Bi_outbuf.add_char ob ')';
    )
      ob x.field9;
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"field10\":";
    (
      Yojson.Safe.write_bool
    )
      ob x.field10;
    if x.field11 <> false then (
      if !is_first then
        is_first := false
      else
        Bi_outbuf.add_char ob ',';
      Bi_outbuf.add_string ob "\"field11\":";
      (
        Yojson.Safe.write_bool
      )
        ob x.field11;
    );
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"field12\":";
    (
      write__10
    )
      ob x.field12;
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"field13\":";
    (
      write__11
    )
      ob x.field13;
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"field14\":";
    (
      write_date
    )
      ob x.field14;
    Bi_outbuf.add_char ob '}';
)
let string_of_mixed_record ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_mixed_record ob x;
  Bi_outbuf.contents ob
let read_mixed_record = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    Yojson.Safe.read_lcurl p lb;
    let field_field0 = ref (None) in
    let field_field1 = ref (None) in
    let field_field2 = ref (None) in
    let field_field3 = ref (None) in
    let field_field4 = ref (None) in
    let field_field5 = ref (None) in
    let field_field6 = ref (None) in
    let field_field7 = ref (None) in
    let field_field8 = ref (None) in
    let field_field9 = ref (None) in
    let field_field10 = ref (None) in
    let field_field11 = ref (false) in
    let field_field12 = ref (None) in
    let field_field13 = ref (None) in
    let field_field14 = ref (None) in
    try
      Yojson.Safe.read_space p lb;
      Yojson.Safe.read_object_end lb;
      Yojson.Safe.read_space p lb;
      let f =
        fun s pos len ->
          if pos < 0 || len < 0 || pos + len > String.length s then
            invalid_arg "out-of-bounds substring position or length";
          match len with
            | 6 -> (
                if String.unsafe_get s pos = 'f' && String.unsafe_get s (pos+1) = 'i' && String.unsafe_get s (pos+2) = 'e' && String.unsafe_get s (pos+3) = 'l' && String.unsafe_get s (pos+4) = 'd' then (
                  match String.unsafe_get s (pos+5) with
                    | '0' -> (
                        0
                      )
                    | '1' -> (
                        1
                      )
                    | '2' -> (
                        2
                      )
                    | '3' -> (
                        3
                      )
                    | '4' -> (
                        4
                      )
                    | '5' -> (
                        5
                      )
                    | '6' -> (
                        6
                      )
                    | '7' -> (
                        7
                      )
                    | '8' -> (
                        8
                      )
                    | '9' -> (
                        9
                      )
                    | _ -> (
                        (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 60, characters 20-703" (String.sub s pos len); -1
                      )
                )
                else (
                  (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 60, characters 20-703" (String.sub s pos len); -1
                )
              )
            | 7 -> (
                if String.unsafe_get s pos = 'f' && String.unsafe_get s (pos+1) = 'i' && String.unsafe_get s (pos+2) = 'e' && String.unsafe_get s (pos+3) = 'l' && String.unsafe_get s (pos+4) = 'd' && String.unsafe_get s (pos+5) = '1' then (
                  match String.unsafe_get s (pos+6) with
                    | '0' -> (
                        10
                      )
                    | '1' -> (
                        11
                      )
                    | '2' -> (
                        12
                      )
                    | '3' -> (
                        13
                      )
                    | '4' -> (
                        14
                      )
                    | _ -> (
                        (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 60, characters 20-703" (String.sub s pos len); -1
                      )
                )
                else (
                  (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 60, characters 20-703" (String.sub s pos len); -1
                )
              )
            | _ -> (
                (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 60, characters 20-703" (String.sub s pos len); -1
              )
      in
      let i = Yojson.Safe.map_ident p f lb in
      Atdgen_runtime.Oj_run.read_until_field_value p lb;
      (
        match i with
          | 0 ->
            if not (Yojson.Safe.read_null_if_possible p lb) then (
              field_field0 := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_int
                  ) p lb
                )
              );
            )
          | 1 ->
            if not (Yojson.Safe.read_null_if_possible p lb) then (
              field_field1 := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_number
                  ) p lb
                )
              );
            )
          | 2 ->
            field_field2 := (
              Some (
                (
                  read__6
                ) p lb
              )
            );
          | 3 ->
            field_field3 := (
              Some (
                (
                  Atdgen_runtime.Oj_run.read_int64
                ) p lb
              )
            );
          | 4 ->
            field_field4 := (
              Some (
                (
                  read__7
                ) p lb
              )
            );
          | 5 ->
            if not (Yojson.Safe.read_null_if_possible p lb) then (
              field_field5 := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_bool
                  ) p lb
                )
              );
            )
          | 6 ->
            if not (Yojson.Safe.read_null_if_possible p lb) then (
              field_field6 := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_string
                  ) p lb
                )
              );
            )
          | 7 ->
            field_field7 := (
              Some (
                (
                  read_test_variant
                ) p lb
              )
            );
          | 8 ->
            field_field8 := (
              Some (
                (
                  read__9
                ) p lb
              )
            );
          | 9 ->
            field_field9 := (
              Some (
                (
                  fun p lb ->
                    Yojson.Safe.read_space p lb;
                    let std_tuple = Yojson.Safe.start_any_tuple p lb in
                    let len = ref 0 in
                    let end_of_tuple = ref false in
                    (try
                      let x0 =
                        let x =
                          (
                            Atdgen_runtime.Oj_run.read_int
                          ) p lb
                        in
                        incr len;
                        Yojson.Safe.read_space p lb;
                        Yojson.Safe.read_tuple_sep2 p std_tuple lb;
                        x
                      in
                      let x1 =
                        let x =
                          (
                            Atdgen_runtime.Oj_run.read_int
                          ) p lb
                        in
                        incr len;
                        Yojson.Safe.read_space p lb;
                        Yojson.Safe.read_tuple_sep2 p std_tuple lb;
                        x
                      in
                      let x2 =
                        let x =
                          (
                            Atdgen_runtime.Oj_run.read_int8
                          ) p lb
                        in
                        incr len;
                        Yojson.Safe.read_space p lb;
                        Yojson.Safe.read_tuple_sep2 p std_tuple lb;
                        x
                      in
                      let x3 =
                        let x =
                          (
                            Atdgen_runtime.Oj_run.read_int
                          ) p lb
                        in
                        incr len;
                        Yojson.Safe.read_space p lb;
                        Yojson.Safe.read_tuple_sep2 p std_tuple lb;
                        x
                      in
                      let x4 =
                        let x =
                          (
                            Atdgen_runtime.Oj_run.read_int32
                          ) p lb
                        in
                        incr len;
                        Yojson.Safe.read_space p lb;
                        Yojson.Safe.read_tuple_sep2 p std_tuple lb;
                        x
                      in
                      let x5 =
                        let x =
                          (
                            Atdgen_runtime.Oj_run.read_int64
                          ) p lb
                        in
                        incr len;
                        (try
                          Yojson.Safe.read_space p lb;
                          Yojson.Safe.read_tuple_sep2 p std_tuple lb;
                        with Yojson.End_of_tuple -> end_of_tuple := true);
                        x
                      in
                      if not !end_of_tuple then (
                        try
                          while true do
                            Yojson.Safe.skip_json p lb;
                            Yojson.Safe.read_space p lb;
                            Yojson.Safe.read_tuple_sep2 p std_tuple lb;
                          done
                        with Yojson.End_of_tuple -> ()
                      );
                      (x0, x1, x2, x3, x4, x5)
                    with Yojson.End_of_tuple ->
                      Atdgen_runtime.Oj_run.missing_tuple_fields p !len [ 0; 1; 2; 3; 4; 5 ]);
                ) p lb
              )
            );
          | 10 ->
            field_field10 := (
              Some (
                (
                  Atdgen_runtime.Oj_run.read_bool
                ) p lb
              )
            );
          | 11 ->
            if not (Yojson.Safe.read_null_if_possible p lb) then (
              field_field11 := (
                (
                  Atdgen_runtime.Oj_run.read_bool
                ) p lb
              );
            )
          | 12 ->
            field_field12 := (
              Some (
                (
                  read__10
                ) p lb
              )
            );
          | 13 ->
            field_field13 := (
              Some (
                (
                  read__11
                ) p lb
              )
            );
          | 14 ->
            field_field14 := (
              Some (
                (
                  read_date
                ) p lb
              )
            );
          | _ -> (
              Yojson.Safe.skip_json p lb
            )
      );
      while true do
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_object_sep p lb;
        Yojson.Safe.read_space p lb;
        let f =
          fun s pos len ->
            if pos < 0 || len < 0 || pos + len > String.length s then
              invalid_arg "out-of-bounds substring position or length";
            match len with
              | 6 -> (
                  if String.unsafe_get s pos = 'f' && String.unsafe_get s (pos+1) = 'i' && String.unsafe_get s (pos+2) = 'e' && String.unsafe_get s (pos+3) = 'l' && String.unsafe_get s (pos+4) = 'd' then (
                    match String.unsafe_get s (pos+5) with
                      | '0' -> (
                          0
                        )
                      | '1' -> (
                          1
                        )
                      | '2' -> (
                          2
                        )
                      | '3' -> (
                          3
                        )
                      | '4' -> (
                          4
                        )
                      | '5' -> (
                          5
                        )
                      | '6' -> (
                          6
                        )
                      | '7' -> (
                          7
                        )
                      | '8' -> (
                          8
                        )
                      | '9' -> (
                          9
                        )
                      | _ -> (
                          (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 60, characters 20-703" (String.sub s pos len); -1
                        )
                  )
                  else (
                    (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 60, characters 20-703" (String.sub s pos len); -1
                  )
                )
              | 7 -> (
                  if String.unsafe_get s pos = 'f' && String.unsafe_get s (pos+1) = 'i' && String.unsafe_get s (pos+2) = 'e' && String.unsafe_get s (pos+3) = 'l' && String.unsafe_get s (pos+4) = 'd' && String.unsafe_get s (pos+5) = '1' then (
                    match String.unsafe_get s (pos+6) with
                      | '0' -> (
                          10
                        )
                      | '1' -> (
                          11
                        )
                      | '2' -> (
                          12
                        )
                      | '3' -> (
                          13
                        )
                      | '4' -> (
                          14
                        )
                      | _ -> (
                          (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 60, characters 20-703" (String.sub s pos len); -1
                        )
                  )
                  else (
                    (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 60, characters 20-703" (String.sub s pos len); -1
                  )
                )
              | _ -> (
                  (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 60, characters 20-703" (String.sub s pos len); -1
                )
        in
        let i = Yojson.Safe.map_ident p f lb in
        Atdgen_runtime.Oj_run.read_until_field_value p lb;
        (
          match i with
            | 0 ->
              if not (Yojson.Safe.read_null_if_possible p lb) then (
                field_field0 := (
                  Some (
                    (
                      Atdgen_runtime.Oj_run.read_int
                    ) p lb
                  )
                );
              )
            | 1 ->
              if not (Yojson.Safe.read_null_if_possible p lb) then (
                field_field1 := (
                  Some (
                    (
                      Atdgen_runtime.Oj_run.read_number
                    ) p lb
                  )
                );
              )
            | 2 ->
              field_field2 := (
                Some (
                  (
                    read__6
                  ) p lb
                )
              );
            | 3 ->
              field_field3 := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_int64
                  ) p lb
                )
              );
            | 4 ->
              field_field4 := (
                Some (
                  (
                    read__7
                  ) p lb
                )
              );
            | 5 ->
              if not (Yojson.Safe.read_null_if_possible p lb) then (
                field_field5 := (
                  Some (
                    (
                      Atdgen_runtime.Oj_run.read_bool
                    ) p lb
                  )
                );
              )
            | 6 ->
              if not (Yojson.Safe.read_null_if_possible p lb) then (
                field_field6 := (
                  Some (
                    (
                      Atdgen_runtime.Oj_run.read_string
                    ) p lb
                  )
                );
              )
            | 7 ->
              field_field7 := (
                Some (
                  (
                    read_test_variant
                  ) p lb
                )
              );
            | 8 ->
              field_field8 := (
                Some (
                  (
                    read__9
                  ) p lb
                )
              );
            | 9 ->
              field_field9 := (
                Some (
                  (
                    fun p lb ->
                      Yojson.Safe.read_space p lb;
                      let std_tuple = Yojson.Safe.start_any_tuple p lb in
                      let len = ref 0 in
                      let end_of_tuple = ref false in
                      (try
                        let x0 =
                          let x =
                            (
                              Atdgen_runtime.Oj_run.read_int
                            ) p lb
                          in
                          incr len;
                          Yojson.Safe.read_space p lb;
                          Yojson.Safe.read_tuple_sep2 p std_tuple lb;
                          x
                        in
                        let x1 =
                          let x =
                            (
                              Atdgen_runtime.Oj_run.read_int
                            ) p lb
                          in
                          incr len;
                          Yojson.Safe.read_space p lb;
                          Yojson.Safe.read_tuple_sep2 p std_tuple lb;
                          x
                        in
                        let x2 =
                          let x =
                            (
                              Atdgen_runtime.Oj_run.read_int8
                            ) p lb
                          in
                          incr len;
                          Yojson.Safe.read_space p lb;
                          Yojson.Safe.read_tuple_sep2 p std_tuple lb;
                          x
                        in
                        let x3 =
                          let x =
                            (
                              Atdgen_runtime.Oj_run.read_int
                            ) p lb
                          in
                          incr len;
                          Yojson.Safe.read_space p lb;
                          Yojson.Safe.read_tuple_sep2 p std_tuple lb;
                          x
                        in
                        let x4 =
                          let x =
                            (
                              Atdgen_runtime.Oj_run.read_int32
                            ) p lb
                          in
                          incr len;
                          Yojson.Safe.read_space p lb;
                          Yojson.Safe.read_tuple_sep2 p std_tuple lb;
                          x
                        in
                        let x5 =
                          let x =
                            (
                              Atdgen_runtime.Oj_run.read_int64
                            ) p lb
                          in
                          incr len;
                          (try
                            Yojson.Safe.read_space p lb;
                            Yojson.Safe.read_tuple_sep2 p std_tuple lb;
                          with Yojson.End_of_tuple -> end_of_tuple := true);
                          x
                        in
                        if not !end_of_tuple then (
                          try
                            while true do
                              Yojson.Safe.skip_json p lb;
                              Yojson.Safe.read_space p lb;
                              Yojson.Safe.read_tuple_sep2 p std_tuple lb;
                            done
                          with Yojson.End_of_tuple -> ()
                        );
                        (x0, x1, x2, x3, x4, x5)
                      with Yojson.End_of_tuple ->
                        Atdgen_runtime.Oj_run.missing_tuple_fields p !len [ 0; 1; 2; 3; 4; 5 ]);
                  ) p lb
                )
              );
            | 10 ->
              field_field10 := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_bool
                  ) p lb
                )
              );
            | 11 ->
              if not (Yojson.Safe.read_null_if_possible p lb) then (
                field_field11 := (
                  (
                    Atdgen_runtime.Oj_run.read_bool
                  ) p lb
                );
              )
            | 12 ->
              field_field12 := (
                Some (
                  (
                    read__10
                  ) p lb
                )
              );
            | 13 ->
              field_field13 := (
                Some (
                  (
                    read__11
                  ) p lb
                )
              );
            | 14 ->
              field_field14 := (
                Some (
                  (
                    read_date
                  ) p lb
                )
              );
            | _ -> (
                Yojson.Safe.skip_json p lb
              )
        );
      done;
      assert false;
    with Yojson.End_of_object -> (
        (
          {
            field0 = !field_field0;
            field1 = !field_field1;
            field2 = (match !field_field2 with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "field2");
            field3 = (match !field_field3 with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "field3");
            field4 = (match !field_field4 with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "field4");
            field5 = !field_field5;
            field6 = !field_field6;
            field7 = (match !field_field7 with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "field7");
            field8 = (match !field_field8 with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "field8");
            field9 = (match !field_field9 with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "field9");
            field10 = (match !field_field10 with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "field10");
            field11 = !field_field11;
            field12 = (match !field_field12 with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "field12");
            field13 = (match !field_field13 with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "field13");
            field14 = (match !field_field14 with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "field14");
          }
         : mixed_record)
      )
)
let mixed_record_of_string s =
  read_mixed_record (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__13 = (
  Atdgen_runtime.Oj_run.write_array (
    write_mixed_record
  )
)
let string_of__13 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__13 ob x;
  Bi_outbuf.contents ob
let read__13 = (
  Atdgen_runtime.Oj_run.read_array (
    read_mixed_record
  )
)
let _13_of_string s =
  read__13 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__12 = (
  Atdgen_runtime.Oj_run.write_array (
    write_mixed_record
  )
)
let string_of__12 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__12 ob x;
  Bi_outbuf.contents ob
let read__12 = (
  Atdgen_runtime.Oj_run.read_array (
    read_mixed_record
  )
)
let _12_of_string s =
  read__12 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__14 = (
  Atdgen_runtime.Oj_run.write_list (
    fun ob x ->
      Bi_outbuf.add_char ob '(';
      (let x, _ = x in
      (
        write__12
      ) ob x
      );
      Bi_outbuf.add_char ob ',';
      (let _, x = x in
      (
        write__13
      ) ob x
      );
      Bi_outbuf.add_char ob ')';
  )
)
let string_of__14 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__14 ob x;
  Bi_outbuf.contents ob
let read__14 = (
  Atdgen_runtime.Oj_run.read_list (
    fun p lb ->
      Yojson.Safe.read_space p lb;
      let std_tuple = Yojson.Safe.start_any_tuple p lb in
      let len = ref 0 in
      let end_of_tuple = ref false in
      (try
        let x0 =
          let x =
            (
              read__12
            ) p lb
          in
          incr len;
          Yojson.Safe.read_space p lb;
          Yojson.Safe.read_tuple_sep2 p std_tuple lb;
          x
        in
        let x1 =
          let x =
            (
              read__13
            ) p lb
          in
          incr len;
          (try
            Yojson.Safe.read_space p lb;
            Yojson.Safe.read_tuple_sep2 p std_tuple lb;
          with Yojson.End_of_tuple -> end_of_tuple := true);
          x
        in
        if not !end_of_tuple then (
          try
            while true do
              Yojson.Safe.skip_json p lb;
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_tuple_sep2 p std_tuple lb;
            done
          with Yojson.End_of_tuple -> ()
        );
        (x0, x1)
      with Yojson.End_of_tuple ->
        Atdgen_runtime.Oj_run.missing_tuple_fields p !len [ 0; 1 ]);
  )
)
let _14_of_string s =
  read__14 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_mixed = (
  write__14
)
let string_of_mixed ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_mixed ob x;
  Bi_outbuf.contents ob
let read_mixed = (
  read__14
)
let mixed_of_string s =
  read_mixed (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__15 = (
  Atdgen_runtime.Oj_run.write_list (
    write_mixed_record
  )
)
let string_of__15 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__15 ob x;
  Bi_outbuf.contents ob
let read__15 = (
  Atdgen_runtime.Oj_run.read_list (
    read_mixed_record
  )
)
let _15_of_string s =
  read__15 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_test : _ -> test -> _ = (
  fun ob (x : test) ->
    Bi_outbuf.add_char ob '{';
    let is_first = ref true in
    (match x.x0 with None -> () | Some x ->
      if !is_first then
        is_first := false
      else
        Bi_outbuf.add_char ob ',';
      Bi_outbuf.add_string ob "\"x0\":";
      (
        Yojson.Safe.write_int
      )
        ob x;
    );
    (match x.x1 with None -> () | Some x ->
      if !is_first then
        is_first := false
      else
        Bi_outbuf.add_char ob ',';
      Bi_outbuf.add_string ob "\"x1\":";
      (
        Yojson.Safe.write_float
      )
        ob x;
    );
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"x2\":";
    (
      write_mixed
    )
      ob x.x2;
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"x3\":";
    (
      write__15
    )
      ob x.x3;
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"x4\":";
    (
      Atdgen_runtime.Oj_run.write_int64
    )
      ob x.x4;
    Bi_outbuf.add_char ob '}';
)
let string_of_test ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_test ob x;
  Bi_outbuf.contents ob
let read_test = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    Yojson.Safe.read_lcurl p lb;
    let field_x0 = ref (None) in
    let field_x1 = ref (None) in
    let field_x2 = ref (None) in
    let field_x3 = ref (None) in
    let field_x4 = ref (None) in
    try
      Yojson.Safe.read_space p lb;
      Yojson.Safe.read_object_end lb;
      Yojson.Safe.read_space p lb;
      let f =
        fun s pos len ->
          if pos < 0 || len < 0 || pos + len > String.length s then
            invalid_arg "out-of-bounds substring position or length";
          if len = 2 && String.unsafe_get s pos = 'x' then (
            match String.unsafe_get s (pos+1) with
              | '0' -> (
                  0
                )
              | '1' -> (
                  1
                )
              | '2' -> (
                  2
                )
              | '3' -> (
                  3
                )
              | '4' -> (
                  4
                )
              | _ -> (
                  (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 90, characters 12-152" (String.sub s pos len); -1
                )
          )
          else (
            (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 90, characters 12-152" (String.sub s pos len); -1
          )
      in
      let i = Yojson.Safe.map_ident p f lb in
      Atdgen_runtime.Oj_run.read_until_field_value p lb;
      (
        match i with
          | 0 ->
            if not (Yojson.Safe.read_null_if_possible p lb) then (
              field_x0 := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_int
                  ) p lb
                )
              );
            )
          | 1 ->
            if not (Yojson.Safe.read_null_if_possible p lb) then (
              field_x1 := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_number
                  ) p lb
                )
              );
            )
          | 2 ->
            field_x2 := (
              Some (
                (
                  read_mixed
                ) p lb
              )
            );
          | 3 ->
            field_x3 := (
              Some (
                (
                  read__15
                ) p lb
              )
            );
          | 4 ->
            field_x4 := (
              Some (
                (
                  Atdgen_runtime.Oj_run.read_int64
                ) p lb
              )
            );
          | _ -> (
              Yojson.Safe.skip_json p lb
            )
      );
      while true do
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_object_sep p lb;
        Yojson.Safe.read_space p lb;
        let f =
          fun s pos len ->
            if pos < 0 || len < 0 || pos + len > String.length s then
              invalid_arg "out-of-bounds substring position or length";
            if len = 2 && String.unsafe_get s pos = 'x' then (
              match String.unsafe_get s (pos+1) with
                | '0' -> (
                    0
                  )
                | '1' -> (
                    1
                  )
                | '2' -> (
                    2
                  )
                | '3' -> (
                    3
                  )
                | '4' -> (
                    4
                  )
                | _ -> (
                    (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 90, characters 12-152" (String.sub s pos len); -1
                  )
            )
            else (
              (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 90, characters 12-152" (String.sub s pos len); -1
            )
        in
        let i = Yojson.Safe.map_ident p f lb in
        Atdgen_runtime.Oj_run.read_until_field_value p lb;
        (
          match i with
            | 0 ->
              if not (Yojson.Safe.read_null_if_possible p lb) then (
                field_x0 := (
                  Some (
                    (
                      Atdgen_runtime.Oj_run.read_int
                    ) p lb
                  )
                );
              )
            | 1 ->
              if not (Yojson.Safe.read_null_if_possible p lb) then (
                field_x1 := (
                  Some (
                    (
                      Atdgen_runtime.Oj_run.read_number
                    ) p lb
                  )
                );
              )
            | 2 ->
              field_x2 := (
                Some (
                  (
                    read_mixed
                  ) p lb
                )
              );
            | 3 ->
              field_x3 := (
                Some (
                  (
                    read__15
                  ) p lb
                )
              );
            | 4 ->
              field_x4 := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_int64
                  ) p lb
                )
              );
            | _ -> (
                Yojson.Safe.skip_json p lb
              )
        );
      done;
      assert false;
    with Yojson.End_of_object -> (
        (
          {
            x0 = !field_x0;
            x1 = !field_x1;
            x2 = (match !field_x2 with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "x2");
            x3 = (match !field_x3 with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "x3");
            x4 = (match !field_x4 with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "x4");
          }
         : test)
      )
)
let test_of_string s =
  read_test (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_tup = (
  fun ob x ->
    Bi_outbuf.add_char ob '(';
    (let x, _ = x in
    (
      Yojson.Safe.write_int
    ) ob x
    );
    Bi_outbuf.add_char ob ',';
    (let _, x = x in
    (
      write_test
    ) ob x
    );
    Bi_outbuf.add_char ob ')';
)
let string_of_tup ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_tup ob x;
  Bi_outbuf.contents ob
let read_tup = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    let std_tuple = Yojson.Safe.start_any_tuple p lb in
    let len = ref 0 in
    let end_of_tuple = ref false in
    (try
      let x0 =
        let x =
          (
            Atdgen_runtime.Oj_run.read_int
          ) p lb
        in
        incr len;
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_tuple_sep2 p std_tuple lb;
        x
      in
      let x1 =
        let x =
          (
            read_test
          ) p lb
        in
        incr len;
        (try
          Yojson.Safe.read_space p lb;
          Yojson.Safe.read_tuple_sep2 p std_tuple lb;
        with Yojson.End_of_tuple -> end_of_tuple := true);
        x
      in
      if not !end_of_tuple then (
        try
          while true do
            Yojson.Safe.skip_json p lb;
            Yojson.Safe.read_space p lb;
            Yojson.Safe.read_tuple_sep2 p std_tuple lb;
          done
        with Yojson.End_of_tuple -> ()
      );
      (x0, x1)
    with Yojson.End_of_tuple ->
      Atdgen_runtime.Oj_run.missing_tuple_fields p !len [ 0; 1 ]);
)
let tup_of_string s =
  read_tup (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_star_rating = (
  Yojson.Safe.write_int
)
let string_of_star_rating ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_star_rating ob x;
  Bi_outbuf.contents ob
let read_star_rating = (
  Atdgen_runtime.Oj_run.read_int
)
let star_rating_of_string s =
  read_star_rating (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__30 : _ -> _ generic -> _ = (
  fun ob (x : _ generic) ->
    Bi_outbuf.add_char ob '{';
    let is_first = ref true in
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"x294623\":";
    (
      Yojson.Safe.write_int
    )
      ob x.x294623;
    Bi_outbuf.add_char ob '}';
)
let string_of__30 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__30 ob x;
  Bi_outbuf.contents ob
let read__30 = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    Yojson.Safe.read_lcurl p lb;
    let field_x294623 = ref (None) in
    try
      Yojson.Safe.read_space p lb;
      Yojson.Safe.read_object_end lb;
      Yojson.Safe.read_space p lb;
      let f =
        fun s pos len ->
          if pos < 0 || len < 0 || pos + len > String.length s then
            invalid_arg "out-of-bounds substring position or length";
          if len = 7 && String.unsafe_get s pos = 'x' && String.unsafe_get s (pos+1) = '2' && String.unsafe_get s (pos+2) = '9' && String.unsafe_get s (pos+3) = '4' && String.unsafe_get s (pos+4) = '6' && String.unsafe_get s (pos+5) = '2' && String.unsafe_get s (pos+6) = '3' then (
            0
          )
          else (
            (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 204, characters 18-33" (String.sub s pos len); -1
          )
      in
      let i = Yojson.Safe.map_ident p f lb in
      Atdgen_runtime.Oj_run.read_until_field_value p lb;
      (
        match i with
          | 0 ->
            field_x294623 := (
              Some (
                (
                  Atdgen_runtime.Oj_run.read_int
                ) p lb
              )
            );
          | _ -> (
              Yojson.Safe.skip_json p lb
            )
      );
      while true do
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_object_sep p lb;
        Yojson.Safe.read_space p lb;
        let f =
          fun s pos len ->
            if pos < 0 || len < 0 || pos + len > String.length s then
              invalid_arg "out-of-bounds substring position or length";
            if len = 7 && String.unsafe_get s pos = 'x' && String.unsafe_get s (pos+1) = '2' && String.unsafe_get s (pos+2) = '9' && String.unsafe_get s (pos+3) = '4' && String.unsafe_get s (pos+4) = '6' && String.unsafe_get s (pos+5) = '2' && String.unsafe_get s (pos+6) = '3' then (
              0
            )
            else (
              (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 204, characters 18-33" (String.sub s pos len); -1
            )
        in
        let i = Yojson.Safe.map_ident p f lb in
        Atdgen_runtime.Oj_run.read_until_field_value p lb;
        (
          match i with
            | 0 ->
              field_x294623 := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_int
                  ) p lb
                )
              );
            | _ -> (
                Yojson.Safe.skip_json p lb
              )
        );
      done;
      assert false;
    with Yojson.End_of_object -> (
        (
          {
            x294623 = (match !field_x294623 with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "x294623");
          }
         : _ generic)
      )
)
let _30_of_string s =
  read__30 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_specialized = (
  write__30
)
let string_of_specialized ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_specialized ob x;
  Bi_outbuf.contents ob
let read_specialized = (
  read__30
)
let specialized_of_string s =
  read_specialized (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_some_record : _ -> some_record -> _ = (
  fun ob (x : some_record) ->
    Bi_outbuf.add_char ob '{';
    let is_first = ref true in
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"some_field\":";
    (
      Yojson.Safe.write_int
    )
      ob x.some_field;
    Bi_outbuf.add_char ob '}';
)
let string_of_some_record ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_some_record ob x;
  Bi_outbuf.contents ob
let read_some_record = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    Yojson.Safe.read_lcurl p lb;
    let field_some_field = ref (None) in
    try
      Yojson.Safe.read_space p lb;
      Yojson.Safe.read_object_end lb;
      Yojson.Safe.read_space p lb;
      let f =
        fun s pos len ->
          if pos < 0 || len < 0 || pos + len > String.length s then
            invalid_arg "out-of-bounds substring position or length";
          if len = 10 && String.unsafe_get s pos = 's' && String.unsafe_get s (pos+1) = 'o' && String.unsafe_get s (pos+2) = 'm' && String.unsafe_get s (pos+3) = 'e' && String.unsafe_get s (pos+4) = '_' && String.unsafe_get s (pos+5) = 'f' && String.unsafe_get s (pos+6) = 'i' && String.unsafe_get s (pos+7) = 'e' && String.unsafe_get s (pos+8) = 'l' && String.unsafe_get s (pos+9) = 'd' then (
            0
          )
          else (
            (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 190, characters 19-95" (String.sub s pos len); -1
          )
      in
      let i = Yojson.Safe.map_ident p f lb in
      Atdgen_runtime.Oj_run.read_until_field_value p lb;
      (
        match i with
          | 0 ->
            field_some_field := (
              Some (
                (
                  Atdgen_runtime.Oj_run.read_int
                ) p lb
              )
            );
          | _ -> (
              Yojson.Safe.skip_json p lb
            )
      );
      while true do
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_object_sep p lb;
        Yojson.Safe.read_space p lb;
        let f =
          fun s pos len ->
            if pos < 0 || len < 0 || pos + len > String.length s then
              invalid_arg "out-of-bounds substring position or length";
            if len = 10 && String.unsafe_get s pos = 's' && String.unsafe_get s (pos+1) = 'o' && String.unsafe_get s (pos+2) = 'm' && String.unsafe_get s (pos+3) = 'e' && String.unsafe_get s (pos+4) = '_' && String.unsafe_get s (pos+5) = 'f' && String.unsafe_get s (pos+6) = 'i' && String.unsafe_get s (pos+7) = 'e' && String.unsafe_get s (pos+8) = 'l' && String.unsafe_get s (pos+9) = 'd' then (
              0
            )
            else (
              (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 190, characters 19-95" (String.sub s pos len); -1
            )
        in
        let i = Yojson.Safe.map_ident p f lb in
        Atdgen_runtime.Oj_run.read_until_field_value p lb;
        (
          match i with
            | 0 ->
              field_some_field := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_int
                  ) p lb
                )
              );
            | _ -> (
                Yojson.Safe.skip_json p lb
              )
        );
      done;
      assert false;
    with Yojson.End_of_object -> (
        (
          {
            some_field = (match !field_some_field with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "some_field");
          }
         : some_record)
      )
)
let some_record_of_string s =
  read_some_record (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_precision : _ -> precision -> _ = (
  fun ob (x : precision) ->
    Bi_outbuf.add_char ob '{';
    let is_first = ref true in
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"sqrt2_5\":";
    (
      Yojson.Safe.write_float_prec 5
    )
      ob x.sqrt2_5;
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"small_2\":";
    (
      Yojson.Safe.write_float_prec 2
    )
      ob x.small_2;
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"large_2\":";
    (
      Yojson.Safe.write_float_prec 2
    )
      ob x.large_2;
    Bi_outbuf.add_char ob '}';
)
let string_of_precision ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_precision ob x;
  Bi_outbuf.contents ob
let read_precision = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    Yojson.Safe.read_lcurl p lb;
    let field_sqrt2_5 = ref (None) in
    let field_small_2 = ref (None) in
    let field_large_2 = ref (None) in
    try
      Yojson.Safe.read_space p lb;
      Yojson.Safe.read_object_end lb;
      Yojson.Safe.read_space p lb;
      let f =
        fun s pos len ->
          if pos < 0 || len < 0 || pos + len > String.length s then
            invalid_arg "out-of-bounds substring position or length";
          if len = 7 then (
            match String.unsafe_get s pos with
              | 'l' -> (
                  if String.unsafe_get s (pos+1) = 'a' && String.unsafe_get s (pos+2) = 'r' && String.unsafe_get s (pos+3) = 'g' && String.unsafe_get s (pos+4) = 'e' && String.unsafe_get s (pos+5) = '_' && String.unsafe_get s (pos+6) = '2' then (
                    2
                  )
                  else (
                    (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 197, characters 17-140" (String.sub s pos len); -1
                  )
                )
              | 's' -> (
                  match String.unsafe_get s (pos+1) with
                    | 'm' -> (
                        if String.unsafe_get s (pos+2) = 'a' && String.unsafe_get s (pos+3) = 'l' && String.unsafe_get s (pos+4) = 'l' && String.unsafe_get s (pos+5) = '_' && String.unsafe_get s (pos+6) = '2' then (
                          1
                        )
                        else (
                          (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 197, characters 17-140" (String.sub s pos len); -1
                        )
                      )
                    | 'q' -> (
                        if String.unsafe_get s (pos+2) = 'r' && String.unsafe_get s (pos+3) = 't' && String.unsafe_get s (pos+4) = '2' && String.unsafe_get s (pos+5) = '_' && String.unsafe_get s (pos+6) = '5' then (
                          0
                        )
                        else (
                          (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 197, characters 17-140" (String.sub s pos len); -1
                        )
                      )
                    | _ -> (
                        (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 197, characters 17-140" (String.sub s pos len); -1
                      )
                )
              | _ -> (
                  (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 197, characters 17-140" (String.sub s pos len); -1
                )
          )
          else (
            (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 197, characters 17-140" (String.sub s pos len); -1
          )
      in
      let i = Yojson.Safe.map_ident p f lb in
      Atdgen_runtime.Oj_run.read_until_field_value p lb;
      (
        match i with
          | 0 ->
            field_sqrt2_5 := (
              Some (
                (
                  Atdgen_runtime.Oj_run.read_number
                ) p lb
              )
            );
          | 1 ->
            field_small_2 := (
              Some (
                (
                  Atdgen_runtime.Oj_run.read_number
                ) p lb
              )
            );
          | 2 ->
            field_large_2 := (
              Some (
                (
                  Atdgen_runtime.Oj_run.read_number
                ) p lb
              )
            );
          | _ -> (
              Yojson.Safe.skip_json p lb
            )
      );
      while true do
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_object_sep p lb;
        Yojson.Safe.read_space p lb;
        let f =
          fun s pos len ->
            if pos < 0 || len < 0 || pos + len > String.length s then
              invalid_arg "out-of-bounds substring position or length";
            if len = 7 then (
              match String.unsafe_get s pos with
                | 'l' -> (
                    if String.unsafe_get s (pos+1) = 'a' && String.unsafe_get s (pos+2) = 'r' && String.unsafe_get s (pos+3) = 'g' && String.unsafe_get s (pos+4) = 'e' && String.unsafe_get s (pos+5) = '_' && String.unsafe_get s (pos+6) = '2' then (
                      2
                    )
                    else (
                      (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 197, characters 17-140" (String.sub s pos len); -1
                    )
                  )
                | 's' -> (
                    match String.unsafe_get s (pos+1) with
                      | 'm' -> (
                          if String.unsafe_get s (pos+2) = 'a' && String.unsafe_get s (pos+3) = 'l' && String.unsafe_get s (pos+4) = 'l' && String.unsafe_get s (pos+5) = '_' && String.unsafe_get s (pos+6) = '2' then (
                            1
                          )
                          else (
                            (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 197, characters 17-140" (String.sub s pos len); -1
                          )
                        )
                      | 'q' -> (
                          if String.unsafe_get s (pos+2) = 'r' && String.unsafe_get s (pos+3) = 't' && String.unsafe_get s (pos+4) = '2' && String.unsafe_get s (pos+5) = '_' && String.unsafe_get s (pos+6) = '5' then (
                            0
                          )
                          else (
                            (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 197, characters 17-140" (String.sub s pos len); -1
                          )
                        )
                      | _ -> (
                          (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 197, characters 17-140" (String.sub s pos len); -1
                        )
                  )
                | _ -> (
                    (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 197, characters 17-140" (String.sub s pos len); -1
                  )
            )
            else (
              (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 197, characters 17-140" (String.sub s pos len); -1
            )
        in
        let i = Yojson.Safe.map_ident p f lb in
        Atdgen_runtime.Oj_run.read_until_field_value p lb;
        (
          match i with
            | 0 ->
              field_sqrt2_5 := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_number
                  ) p lb
                )
              );
            | 1 ->
              field_small_2 := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_number
                  ) p lb
                )
              );
            | 2 ->
              field_large_2 := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_number
                  ) p lb
                )
              );
            | _ -> (
                Yojson.Safe.skip_json p lb
              )
        );
      done;
      assert false;
    with Yojson.End_of_object -> (
        (
          {
            sqrt2_5 = (match !field_sqrt2_5 with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "sqrt2_5");
            small_2 = (match !field_small_2 with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "small_2");
            large_2 = (match !field_large_2 with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "large_2");
          }
         : precision)
      )
)
let precision_of_string s =
  read_precision (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_p'' = (
  write__1
)
let string_of_p'' ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_p'' ob x;
  Bi_outbuf.contents ob
let read_p'' = (
  read__1
)
let p''_of_string s =
  read_p'' (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__18 = (
  Atdgen_runtime.Oj_run.write_option (
    Yojson.Safe.write_int
  )
)
let string_of__18 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__18 ob x;
  Bi_outbuf.contents ob
let read__18 = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    match Yojson.Safe.start_any_variant p lb with
      | `Edgy_bracket -> (
          match Yojson.Safe.read_ident p lb with
            | "None" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              (None : _ option)
            | "Some" ->
              Atdgen_runtime.Oj_run.read_until_field_value p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_int
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              (Some x : _ option)
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Double_quote -> (
          match Yojson.Safe.finish_string p lb with
            | "None" ->
              (None : _ option)
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Square_bracket -> (
          match Atdgen_runtime.Oj_run.read_string p lb with
            | "Some" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_comma p lb;
              Yojson.Safe.read_space p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_int
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_rbr p lb;
              (Some x : _ option)
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
)
let _18_of_string s =
  read__18 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_option_validation = (
  write__18
)
let string_of_option_validation ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_option_validation ob x;
  Bi_outbuf.contents ob
let read_option_validation = (
  read__18
)
let option_validation_of_string s =
  read_option_validation (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__28 = (
  write_some_record
)
let string_of__28 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__28 ob x;
  Bi_outbuf.contents ob
let read__28 = (
  read_some_record
)
let _28_of_string s =
  read__28 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_no_real_wrap = (
  write__28
)
let string_of_no_real_wrap ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_no_real_wrap ob x;
  Bi_outbuf.contents ob
let read_no_real_wrap = (
  read__28
)
let no_real_wrap_of_string s =
  read_no_real_wrap (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__26 = (
  fun ob x -> (
    let x = ( Test_lib.Natural.unwrap ) x in (
      Yojson.Safe.write_int
    ) ob x)
)
let string_of__26 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__26 ob x;
  Bi_outbuf.contents ob
let read__26 = (
  fun p lb ->
    let x = (
      Atdgen_runtime.Oj_run.read_int
    ) p lb in
    ( Test_lib.Natural.wrap ) x
)
let _26_of_string s =
  read__26 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_natural = (
  write__26
)
let string_of_natural ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_natural ob x;
  Bi_outbuf.contents ob
let read_natural = (
  read__26
)
let natural_of_string s =
  read_natural (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__24 = (
  fun ob x -> (
    let x = ( function `Id s -> s ) x in (
      Yojson.Safe.write_string
    ) ob x)
)
let string_of__24 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__24 ob x;
  Bi_outbuf.contents ob
let read__24 = (
  fun p lb ->
    let x = (
      Atdgen_runtime.Oj_run.read_string
    ) p lb in
    ( fun s -> `Id s ) x
)
let _24_of_string s =
  read__24 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_id = (
  write__24
)
let string_of_id ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_id ob x;
  Bi_outbuf.contents ob
let read_id = (
  read__24
)
let id_of_string s =
  read_id (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__25 = (
  Atdgen_runtime.Oj_run.write_assoc_list (
    write_id
  ) (
    Yojson.Safe.write_int
  )
)
let string_of__25 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__25 ob x;
  Bi_outbuf.contents ob
let read__25 = (
  Atdgen_runtime.Oj_run.read_assoc_list (
    read_id
  ) (
    Atdgen_runtime.Oj_run.read_int
  )
)
let _25_of_string s =
  read__25 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_json_map = (
  write__25
)
let string_of_json_map ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_json_map ob x;
  Bi_outbuf.contents ob
let read_json_map = (
  read__25
)
let json_map_of_string s =
  read_json_map (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_intopt = (
  write__4
)
let string_of_intopt ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_intopt ob x;
  Bi_outbuf.contents ob
let read_intopt = (
  read__4
)
let intopt_of_string s =
  read_intopt (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__21 = (
  Atdgen_runtime.Oj_run.write_assoc_list (
    Yojson.Safe.write_string
  ) (
    Yojson.Safe.write_int
  )
)
let string_of__21 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__21 ob x;
  Bi_outbuf.contents ob
let read__21 = (
  Atdgen_runtime.Oj_run.read_assoc_list (
    Atdgen_runtime.Oj_run.read_string
  ) (
    Atdgen_runtime.Oj_run.read_int
  )
)
let _21_of_string s =
  read__21 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_int_assoc_list = (
  write__21
)
let string_of_int_assoc_list ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_int_assoc_list ob x;
  Bi_outbuf.contents ob
let read_int_assoc_list = (
  read__21
)
let int_assoc_list_of_string s =
  read_int_assoc_list (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__22 = (
  Atdgen_runtime.Oj_run.write_assoc_array (
    Yojson.Safe.write_string
  ) (
    Yojson.Safe.write_int
  )
)
let string_of__22 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__22 ob x;
  Bi_outbuf.contents ob
let read__22 = (
  Atdgen_runtime.Oj_run.read_assoc_array (
    Atdgen_runtime.Oj_run.read_string
  ) (
    Atdgen_runtime.Oj_run.read_int
  )
)
let _22_of_string s =
  read__22 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_int_assoc_array = (
  write__22
)
let string_of_int_assoc_array ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_int_assoc_array ob x;
  Bi_outbuf.contents ob
let read_int_assoc_array = (
  read__22
)
let int_assoc_array_of_string s =
  read_int_assoc_array (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_int8 = (
  Yojson.Safe.write_int
)
let string_of_int8 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_int8 ob x;
  Bi_outbuf.contents ob
let read_int8 = (
  Atdgen_runtime.Oj_run.read_int
)
let int8_of_string s =
  read_int8 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_int64 = (
  Atdgen_runtime.Oj_run.write_int64
)
let string_of_int64 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_int64 ob x;
  Bi_outbuf.contents ob
let read_int64 = (
  Atdgen_runtime.Oj_run.read_int64
)
let int64_of_string s =
  read_int64 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_int32 = (
  Atdgen_runtime.Oj_run.write_int32
)
let string_of_int32 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_int32 ob x;
  Bi_outbuf.contents ob
let read_int32 = (
  Atdgen_runtime.Oj_run.read_int32
)
let int32_of_string s =
  read_int32 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_hello = (
  fun ob x ->
    match x with
      | `Hello x ->
        Bi_outbuf.add_string ob "<\"Hello\":";
        (
          Yojson.Safe.write_string
        ) ob x;
        Bi_outbuf.add_char ob '>'
      | `World -> Bi_outbuf.add_string ob "<\"World\">"
)
let string_of_hello ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_hello ob x;
  Bi_outbuf.contents ob
let read_hello = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    match Yojson.Safe.start_any_variant p lb with
      | `Edgy_bracket -> (
          match Yojson.Safe.read_ident p lb with
            | "Hello" ->
              Atdgen_runtime.Oj_run.read_until_field_value p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_string
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              `Hello x
            | "World" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              `World
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Double_quote -> (
          match Yojson.Safe.finish_string p lb with
            | "World" ->
              `World
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Square_bracket -> (
          match Atdgen_runtime.Oj_run.read_string p lb with
            | "Hello" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_comma p lb;
              Yojson.Safe.read_space p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_string
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_rbr p lb;
              `Hello x
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
)
let hello_of_string s =
  read_hello (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_generic write__a : _ -> 'a generic -> _ = (
  fun ob (x : 'a generic) ->
    Bi_outbuf.add_char ob '{';
    let is_first = ref true in
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"x294623\":";
    (
      Yojson.Safe.write_int
    )
      ob x.x294623;
    Bi_outbuf.add_char ob '}';
)
let string_of_generic write__a ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_generic write__a ob x;
  Bi_outbuf.contents ob
let read_generic read__a = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    Yojson.Safe.read_lcurl p lb;
    let field_x294623 = ref (None) in
    try
      Yojson.Safe.read_space p lb;
      Yojson.Safe.read_object_end lb;
      Yojson.Safe.read_space p lb;
      let f =
        fun s pos len ->
          if pos < 0 || len < 0 || pos + len > String.length s then
            invalid_arg "out-of-bounds substring position or length";
          if len = 7 && String.unsafe_get s pos = 'x' && String.unsafe_get s (pos+1) = '2' && String.unsafe_get s (pos+2) = '9' && String.unsafe_get s (pos+3) = '4' && String.unsafe_get s (pos+4) = '6' && String.unsafe_get s (pos+5) = '2' && String.unsafe_get s (pos+6) = '3' then (
            0
          )
          else (
            (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 203, characters 18-35" (String.sub s pos len); -1
          )
      in
      let i = Yojson.Safe.map_ident p f lb in
      Atdgen_runtime.Oj_run.read_until_field_value p lb;
      (
        match i with
          | 0 ->
            field_x294623 := (
              Some (
                (
                  Atdgen_runtime.Oj_run.read_int
                ) p lb
              )
            );
          | _ -> (
              Yojson.Safe.skip_json p lb
            )
      );
      while true do
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_object_sep p lb;
        Yojson.Safe.read_space p lb;
        let f =
          fun s pos len ->
            if pos < 0 || len < 0 || pos + len > String.length s then
              invalid_arg "out-of-bounds substring position or length";
            if len = 7 && String.unsafe_get s pos = 'x' && String.unsafe_get s (pos+1) = '2' && String.unsafe_get s (pos+2) = '9' && String.unsafe_get s (pos+3) = '4' && String.unsafe_get s (pos+4) = '6' && String.unsafe_get s (pos+5) = '2' && String.unsafe_get s (pos+6) = '3' then (
              0
            )
            else (
              (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 203, characters 18-35" (String.sub s pos len); -1
            )
        in
        let i = Yojson.Safe.map_ident p f lb in
        Atdgen_runtime.Oj_run.read_until_field_value p lb;
        (
          match i with
            | 0 ->
              field_x294623 := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_int
                  ) p lb
                )
              );
            | _ -> (
                Yojson.Safe.skip_json p lb
              )
        );
      done;
      assert false;
    with Yojson.End_of_object -> (
        (
          {
            x294623 = (match !field_x294623 with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "x294623");
          }
         : 'a generic)
      )
)
let generic_of_string read__a s =
  read_generic read__a (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_floats : _ -> floats -> _ = (
  fun ob (x : floats) ->
    Bi_outbuf.add_char ob '{';
    let is_first = ref true in
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"f32\":";
    (
      Yojson.Safe.write_float
    )
      ob x.f32;
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"f64\":";
    (
      Yojson.Safe.write_float
    )
      ob x.f64;
    Bi_outbuf.add_char ob '}';
)
let string_of_floats ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_floats ob x;
  Bi_outbuf.contents ob
let read_floats = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    Yojson.Safe.read_lcurl p lb;
    let field_f32 = ref (None) in
    let field_f64 = ref (None) in
    try
      Yojson.Safe.read_space p lb;
      Yojson.Safe.read_object_end lb;
      Yojson.Safe.read_space p lb;
      let f =
        fun s pos len ->
          if pos < 0 || len < 0 || pos + len > String.length s then
            invalid_arg "out-of-bounds substring position or length";
          if len = 3 && String.unsafe_get s pos = 'f' then (
            match String.unsafe_get s (pos+1) with
              | '3' -> (
                  if String.unsafe_get s (pos+2) = '2' then (
                    0
                  )
                  else (
                    (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 55, characters 14-71" (String.sub s pos len); -1
                  )
                )
              | '6' -> (
                  if String.unsafe_get s (pos+2) = '4' then (
                    1
                  )
                  else (
                    (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 55, characters 14-71" (String.sub s pos len); -1
                  )
                )
              | _ -> (
                  (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 55, characters 14-71" (String.sub s pos len); -1
                )
          )
          else (
            (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 55, characters 14-71" (String.sub s pos len); -1
          )
      in
      let i = Yojson.Safe.map_ident p f lb in
      Atdgen_runtime.Oj_run.read_until_field_value p lb;
      (
        match i with
          | 0 ->
            field_f32 := (
              Some (
                (
                  Atdgen_runtime.Oj_run.read_number
                ) p lb
              )
            );
          | 1 ->
            field_f64 := (
              Some (
                (
                  Atdgen_runtime.Oj_run.read_number
                ) p lb
              )
            );
          | _ -> (
              Yojson.Safe.skip_json p lb
            )
      );
      while true do
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_object_sep p lb;
        Yojson.Safe.read_space p lb;
        let f =
          fun s pos len ->
            if pos < 0 || len < 0 || pos + len > String.length s then
              invalid_arg "out-of-bounds substring position or length";
            if len = 3 && String.unsafe_get s pos = 'f' then (
              match String.unsafe_get s (pos+1) with
                | '3' -> (
                    if String.unsafe_get s (pos+2) = '2' then (
                      0
                    )
                    else (
                      (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 55, characters 14-71" (String.sub s pos len); -1
                    )
                  )
                | '6' -> (
                    if String.unsafe_get s (pos+2) = '4' then (
                      1
                    )
                    else (
                      (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 55, characters 14-71" (String.sub s pos len); -1
                    )
                  )
                | _ -> (
                    (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 55, characters 14-71" (String.sub s pos len); -1
                  )
            )
            else (
              (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 55, characters 14-71" (String.sub s pos len); -1
            )
        in
        let i = Yojson.Safe.map_ident p f lb in
        Atdgen_runtime.Oj_run.read_until_field_value p lb;
        (
          match i with
            | 0 ->
              field_f32 := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_number
                  ) p lb
                )
              );
            | 1 ->
              field_f64 := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_number
                  ) p lb
                )
              );
            | _ -> (
                Yojson.Safe.skip_json p lb
              )
        );
      done;
      assert false;
    with Yojson.End_of_object -> (
        (
          {
            f32 = (match !field_f32 with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "f32");
            f64 = (match !field_f64 with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "f64");
          }
         : floats)
      )
)
let floats_of_string s =
  read_floats (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__17 = (
  Atdgen_runtime.Oj_run.write_list (
    Yojson.Safe.write_string
  )
)
let string_of__17 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__17 ob x;
  Bi_outbuf.contents ob
let read__17 = (
  Atdgen_runtime.Oj_run.read_list (
    Atdgen_runtime.Oj_run.read_string
  )
)
let _17_of_string s =
  read__17 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_extended_tuple = (
  fun ob x ->
    Bi_outbuf.add_char ob '(';
    (let x, _, _, _, _, _ = x in
    (
      Yojson.Safe.write_int
    ) ob x
    );
    Bi_outbuf.add_char ob ',';
    (let _, x, _, _, _, _ = x in
    (
      Yojson.Safe.write_float
    ) ob x
    );
    Bi_outbuf.add_char ob ',';
    (let _, _, x, _, _, _ = x in
    (
      Yojson.Safe.write_bool
    ) ob x
    );
    Bi_outbuf.add_char ob ',';
    (let _, _, _, x, _, _ = x in
    (
      write__4
    ) ob x
    );
    Bi_outbuf.add_char ob ',';
    (let _, _, _, _, x, _ = x in
    (
      Yojson.Safe.write_string
    ) ob x
    );
    Bi_outbuf.add_char ob ',';
    (let _, _, _, _, _, x = x in
    (
      write__17
    ) ob x
    );
    Bi_outbuf.add_char ob ')';
)
let string_of_extended_tuple ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_extended_tuple ob x;
  Bi_outbuf.contents ob
let read_extended_tuple = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    let std_tuple = Yojson.Safe.start_any_tuple p lb in
    let len = ref 0 in
    let end_of_tuple = ref false in
    (try
      let x0 =
        let x =
          (
            Atdgen_runtime.Oj_run.read_int
          ) p lb
        in
        incr len;
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_tuple_sep2 p std_tuple lb;
        x
      in
      let x1 =
        let x =
          (
            Atdgen_runtime.Oj_run.read_number
          ) p lb
        in
        incr len;
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_tuple_sep2 p std_tuple lb;
        x
      in
      let x2 =
        let x =
          (
            Atdgen_runtime.Oj_run.read_bool
          ) p lb
        in
        incr len;
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_tuple_sep2 p std_tuple lb;
        x
      in
      let x3 =
        let x =
          (
            read__4
          ) p lb
        in
        incr len;
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_tuple_sep2 p std_tuple lb;
        x
      in
      let x4 =
        let x =
          (
            Atdgen_runtime.Oj_run.read_string
          ) p lb
        in
        incr len;
        (try
          Yojson.Safe.read_space p lb;
          Yojson.Safe.read_tuple_sep2 p std_tuple lb;
        with Yojson.End_of_tuple -> end_of_tuple := true);
        x
      in
      let x5 =
        if !end_of_tuple then ([])
        else (
          let x = (
            (
              read__17
            ) p lb
          ) in
          incr len;
          (try
            Yojson.Safe.read_space p lb;
            Yojson.Safe.read_tuple_sep2 p std_tuple lb;
          with Yojson.End_of_tuple ->
            end_of_tuple := true);
          x
        )
      in
      if not !end_of_tuple then (
        try
          while true do
            Yojson.Safe.skip_json p lb;
            Yojson.Safe.read_space p lb;
            Yojson.Safe.read_tuple_sep2 p std_tuple lb;
          done
        with Yojson.End_of_tuple -> ()
      );
      (x0, x1, x2, x3, x4, x5)
    with Yojson.End_of_tuple ->
      Atdgen_runtime.Oj_run.missing_tuple_fields p !len [ 0; 1; 4 ]);
)
let extended_tuple_of_string s =
  read_extended_tuple (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_extended : _ -> extended -> _ = (
  fun ob (x : extended) ->
    Bi_outbuf.add_char ob '{';
    let is_first = ref true in
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"b0\":";
    (
      Yojson.Safe.write_int
    )
      ob x.b0x;
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"b1\":";
    (
      Yojson.Safe.write_bool
    )
      ob x.b1x;
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"b2\":";
    (
      Yojson.Safe.write_string
    )
      ob x.b2x;
    (match x.b3x with None -> () | Some x ->
      if !is_first then
        is_first := false
      else
        Bi_outbuf.add_char ob ',';
      Bi_outbuf.add_string ob "\"b3\":";
      (
        Yojson.Safe.write_string
      )
        ob x;
    );
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"b4\":";
    (
      write__6
    )
      ob x.b4x;
    if x.b5x <> 0.5 then (
      if !is_first then
        is_first := false
      else
        Bi_outbuf.add_char ob ',';
      Bi_outbuf.add_string ob "\"b5\":";
      (
        Yojson.Safe.write_float
      )
        ob x.b5x;
    );
    Bi_outbuf.add_char ob '}';
)
let string_of_extended ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_extended ob x;
  Bi_outbuf.contents ob
let read_extended = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    Yojson.Safe.read_lcurl p lb;
    let field_b0x = ref (None) in
    let field_b1x = ref (None) in
    let field_b2x = ref (None) in
    let field_b3x = ref (None) in
    let field_b4x = ref (None) in
    let field_b5x = ref (0.5) in
    try
      Yojson.Safe.read_space p lb;
      Yojson.Safe.read_object_end lb;
      Yojson.Safe.read_space p lb;
      let f =
        fun s pos len ->
          if pos < 0 || len < 0 || pos + len > String.length s then
            invalid_arg "out-of-bounds substring position or length";
          if len = 2 && String.unsafe_get s pos = 'b' then (
            match String.unsafe_get s (pos+1) with
              | '0' -> (
                  0
                )
              | '1' -> (
                  1
                )
              | '2' -> (
                  2
                )
              | '3' -> (
                  3
                )
              | '4' -> (
                  4
                )
              | '5' -> (
                  5
                )
              | _ -> (
                  (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 103, characters 16-508" (String.sub s pos len); -1
                )
          )
          else (
            (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 103, characters 16-508" (String.sub s pos len); -1
          )
      in
      let i = Yojson.Safe.map_ident p f lb in
      Atdgen_runtime.Oj_run.read_until_field_value p lb;
      (
        match i with
          | 0 ->
            field_b0x := (
              Some (
                (
                  Atdgen_runtime.Oj_run.read_int
                ) p lb
              )
            );
          | 1 ->
            field_b1x := (
              Some (
                (
                  Atdgen_runtime.Oj_run.read_bool
                ) p lb
              )
            );
          | 2 ->
            field_b2x := (
              Some (
                (
                  Atdgen_runtime.Oj_run.read_string
                ) p lb
              )
            );
          | 3 ->
            if not (Yojson.Safe.read_null_if_possible p lb) then (
              field_b3x := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_string
                  ) p lb
                )
              );
            )
          | 4 ->
            field_b4x := (
              Some (
                (
                  read__6
                ) p lb
              )
            );
          | 5 ->
            if not (Yojson.Safe.read_null_if_possible p lb) then (
              field_b5x := (
                (
                  Atdgen_runtime.Oj_run.read_number
                ) p lb
              );
            )
          | _ -> (
              Yojson.Safe.skip_json p lb
            )
      );
      while true do
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_object_sep p lb;
        Yojson.Safe.read_space p lb;
        let f =
          fun s pos len ->
            if pos < 0 || len < 0 || pos + len > String.length s then
              invalid_arg "out-of-bounds substring position or length";
            if len = 2 && String.unsafe_get s pos = 'b' then (
              match String.unsafe_get s (pos+1) with
                | '0' -> (
                    0
                  )
                | '1' -> (
                    1
                  )
                | '2' -> (
                    2
                  )
                | '3' -> (
                    3
                  )
                | '4' -> (
                    4
                  )
                | '5' -> (
                    5
                  )
                | _ -> (
                    (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 103, characters 16-508" (String.sub s pos len); -1
                  )
            )
            else (
              (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 103, characters 16-508" (String.sub s pos len); -1
            )
        in
        let i = Yojson.Safe.map_ident p f lb in
        Atdgen_runtime.Oj_run.read_until_field_value p lb;
        (
          match i with
            | 0 ->
              field_b0x := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_int
                  ) p lb
                )
              );
            | 1 ->
              field_b1x := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_bool
                  ) p lb
                )
              );
            | 2 ->
              field_b2x := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_string
                  ) p lb
                )
              );
            | 3 ->
              if not (Yojson.Safe.read_null_if_possible p lb) then (
                field_b3x := (
                  Some (
                    (
                      Atdgen_runtime.Oj_run.read_string
                    ) p lb
                  )
                );
              )
            | 4 ->
              field_b4x := (
                Some (
                  (
                    read__6
                  ) p lb
                )
              );
            | 5 ->
              if not (Yojson.Safe.read_null_if_possible p lb) then (
                field_b5x := (
                  (
                    Atdgen_runtime.Oj_run.read_number
                  ) p lb
                );
              )
            | _ -> (
                Yojson.Safe.skip_json p lb
              )
        );
      done;
      assert false;
    with Yojson.End_of_object -> (
        (
          {
            b0x = (match !field_b0x with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "b0x");
            b1x = (match !field_b1x with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "b1x");
            b2x = (match !field_b2x with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "b2x");
            b3x = !field_b3x;
            b4x = (match !field_b4x with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "b4x");
            b5x = !field_b5x;
          }
         : extended)
      )
)
let extended_of_string s =
  read_extended (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__27 = (
  fun ob x -> (
    let x = ( Test_lib.Even_natural.unwrap ) x in (
      write_natural
    ) ob x)
)
let string_of__27 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__27 ob x;
  Bi_outbuf.contents ob
let read__27 = (
  fun p lb ->
    let x = (
      read_natural
    ) p lb in
    ( Test_lib.Even_natural.wrap ) x
)
let _27_of_string s =
  read__27 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_even_natural = (
  write__27
)
let string_of_even_natural ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_even_natural ob x;
  Bi_outbuf.contents ob
let read_even_natural = (
  read__27
)
let even_natural_of_string s =
  read_even_natural (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_def = (
  Test_lib.Json.write_def
)
let string_of_def ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_def ob x;
  Bi_outbuf.contents ob
let read_def = (
  Test_lib.Json.read_def
)
let def_of_string s =
  read_def (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_char = (
  Atdgen_runtime.Oj_run.write_int8
)
let string_of_char ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_char ob x;
  Bi_outbuf.contents ob
let read_char = (
  Atdgen_runtime.Oj_run.read_int8
)
let char_of_string s =
  read_char (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_base_tuple = (
  fun ob x ->
    Bi_outbuf.add_char ob '(';
    (let x, _ = x in
    (
      Yojson.Safe.write_int
    ) ob x
    );
    Bi_outbuf.add_char ob ',';
    (let _, x = x in
    (
      Yojson.Safe.write_float
    ) ob x
    );
    Bi_outbuf.add_char ob ')';
)
let string_of_base_tuple ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_base_tuple ob x;
  Bi_outbuf.contents ob
let read_base_tuple = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    let std_tuple = Yojson.Safe.start_any_tuple p lb in
    let len = ref 0 in
    let end_of_tuple = ref false in
    (try
      let x0 =
        let x =
          (
            Atdgen_runtime.Oj_run.read_int
          ) p lb
        in
        incr len;
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_tuple_sep2 p std_tuple lb;
        x
      in
      let x1 =
        let x =
          (
            Atdgen_runtime.Oj_run.read_number
          ) p lb
        in
        incr len;
        (try
          Yojson.Safe.read_space p lb;
          Yojson.Safe.read_tuple_sep2 p std_tuple lb;
        with Yojson.End_of_tuple -> end_of_tuple := true);
        x
      in
      if not !end_of_tuple then (
        try
          while true do
            Yojson.Safe.skip_json p lb;
            Yojson.Safe.read_space p lb;
            Yojson.Safe.read_tuple_sep2 p std_tuple lb;
          done
        with Yojson.End_of_tuple -> ()
      );
      (x0, x1)
    with Yojson.End_of_tuple ->
      Atdgen_runtime.Oj_run.missing_tuple_fields p !len [ 0; 1 ]);
)
let base_tuple_of_string s =
  read_base_tuple (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_base : _ -> base -> _ = (
  fun ob (x : base) ->
    Bi_outbuf.add_char ob '{';
    let is_first = ref true in
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"b0\":";
    (
      Yojson.Safe.write_int
    )
      ob x.b0;
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"b1\":";
    (
      Yojson.Safe.write_bool
    )
      ob x.b1;
    Bi_outbuf.add_char ob '}';
)
let string_of_base ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_base ob x;
  Bi_outbuf.contents ob
let read_base = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    Yojson.Safe.read_lcurl p lb;
    let field_b0 = ref (None) in
    let field_b1 = ref (None) in
    try
      Yojson.Safe.read_space p lb;
      Yojson.Safe.read_object_end lb;
      Yojson.Safe.read_space p lb;
      let f =
        fun s pos len ->
          if pos < 0 || len < 0 || pos + len > String.length s then
            invalid_arg "out-of-bounds substring position or length";
          if len = 2 && String.unsafe_get s pos = 'b' then (
            match String.unsafe_get s (pos+1) with
              | '0' -> (
                  0
                )
              | '1' -> (
                  1
                )
              | _ -> (
                  (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 98, characters 12-40" (String.sub s pos len); -1
                )
          )
          else (
            (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 98, characters 12-40" (String.sub s pos len); -1
          )
      in
      let i = Yojson.Safe.map_ident p f lb in
      Atdgen_runtime.Oj_run.read_until_field_value p lb;
      (
        match i with
          | 0 ->
            field_b0 := (
              Some (
                (
                  Atdgen_runtime.Oj_run.read_int
                ) p lb
              )
            );
          | 1 ->
            field_b1 := (
              Some (
                (
                  Atdgen_runtime.Oj_run.read_bool
                ) p lb
              )
            );
          | _ -> (
              Yojson.Safe.skip_json p lb
            )
      );
      while true do
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_object_sep p lb;
        Yojson.Safe.read_space p lb;
        let f =
          fun s pos len ->
            if pos < 0 || len < 0 || pos + len > String.length s then
              invalid_arg "out-of-bounds substring position or length";
            if len = 2 && String.unsafe_get s pos = 'b' then (
              match String.unsafe_get s (pos+1) with
                | '0' -> (
                    0
                  )
                | '1' -> (
                    1
                  )
                | _ -> (
                    (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 98, characters 12-40" (String.sub s pos len); -1
                  )
            )
            else (
              (fun loc s -> Printf.eprintf "Warning: skipping field %s (def: %s)
" s loc) "File \"test.atd\", line 98, characters 12-40" (String.sub s pos len); -1
            )
        in
        let i = Yojson.Safe.map_ident p f lb in
        Atdgen_runtime.Oj_run.read_until_field_value p lb;
        (
          match i with
            | 0 ->
              field_b0 := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_int
                  ) p lb
                )
              );
            | 1 ->
              field_b1 := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_bool
                  ) p lb
                )
              );
            | _ -> (
                Yojson.Safe.skip_json p lb
              )
        );
      done;
      assert false;
    with Yojson.End_of_object -> (
        (
          {
            b0 = (match !field_b0 with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "b0");
            b1 = (match !field_b1 with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "b1");
          }
         : base)
      )
)
let base_of_string s =
  read_base (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__23 write__a = (
  Atdgen_runtime.Oj_run.write_array (
    write__a
  )
)
let string_of__23 write__a ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__23 write__a ob x;
  Bi_outbuf.contents ob
let read__23 read__a = (
  Atdgen_runtime.Oj_run.read_array (
    read__a
  )
)
let _23_of_string read__a s =
  read__23 read__a (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_array write__a = (
  write__23 write__a
)
let string_of_array write__a ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_array write__a ob x;
  Bi_outbuf.contents ob
let read_array read__a = (
  read__23 read__a
)
let array_of_string read__a s =
  read_array read__a (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_abs3 write__a = (
  write__19 write__a
)
let string_of_abs3 write__a ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_abs3 write__a ob x;
  Bi_outbuf.contents ob
let read_abs3 read__a = (
  read__19 read__a
)
let abs3_of_string read__a s =
  read_abs3 read__a (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_abs2 write__a = (
  write__19 write__a
)
let string_of_abs2 write__a ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_abs2 write__a ob x;
  Bi_outbuf.contents ob
let read_abs2 read__a = (
  read__19 read__a
)
let abs2_of_string read__a s =
  read_abs2 read__a (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_abs1 write__a = (
  write__19 write__a
)
let string_of_abs1 write__a ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_abs1 write__a ob x;
  Bi_outbuf.contents ob
let read_abs1 read__a = (
  read__19 read__a
)
let abs1_of_string read__a s =
  read_abs1 read__a (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let create_r 
  ~a
  ~b
  ~c
  () : r =
  {
    a = a;
    b = b;
    c = c;
  }
let create_poly 
  ~fst
  ~snd
  () : ('x, 'y) poly =
  {
    fst = fst;
    snd = snd;
  }
let create_val1 
  ~val1_x
  () : val1 =
  {
    val1_x = val1_x;
  }
let create_val2 
  ~val2_x
  ?val2_y
  () : val2 =
  {
    val2_x = val2_x;
    val2_y = val2_y;
  }
let create_mixed_record 
  ?field0
  ?field1
  ~field2
  ~field3
  ~field4
  ?field5
  ?field6
  ~field7
  ~field8
  ~field9
  ~field10
  ?(field11 = false)
  ~field12
  ~field13
  ~field14
  () : mixed_record =
  {
    field0 = field0;
    field1 = field1;
    field2 = field2;
    field3 = field3;
    field4 = field4;
    field5 = field5;
    field6 = field6;
    field7 = field7;
    field8 = field8;
    field9 = field9;
    field10 = field10;
    field11 = field11;
    field12 = field12;
    field13 = field13;
    field14 = field14;
  }
let create_test 
  ?x0
  ?x1
  ~x2
  ~x3
  ~x4
  () : test =
  {
    x0 = x0;
    x1 = x1;
    x2 = x2;
    x3 = x3;
    x4 = x4;
  }
let create_some_record 
  ~some_field
  () : some_record =
  {
    some_field = some_field;
  }
let create_precision 
  ~sqrt2_5
  ~small_2
  ~large_2
  () : precision =
  {
    sqrt2_5 = sqrt2_5;
    small_2 = small_2;
    large_2 = large_2;
  }
let create_generic 
  ~x294623
  () : 'a generic =
  {
    x294623 = x294623;
  }
let create_floats 
  ~f32
  ~f64
  () : floats =
  {
    f32 = f32;
    f64 = f64;
  }
let create_extended 
  ~b0x
  ~b1x
  ~b2x
  ?b3x
  ~b4x
  ?(b5x = 0.5)
  () : extended =
  {
    b0x = b0x;
    b1x = b1x;
    b2x = b2x;
    b3x = b3x;
    b4x = b4x;
    b5x = b5x;
  }
let create_base 
  ~b0
  ~b1
  () : base =
  {
    b0 = b0;
    b1 = b1;
  }
atd-2.1.0/atdgen/test/testj.expected.mli000066400000000000000000000766101357165332000201560ustar00rootroot00000000000000(* Auto-generated from "test.atd" *)
[@@@ocaml.warning "-27-32-35-39"]

(** This is just a test. *)

type test_variant = Test.test_variant

type ('x, 'y) poly = ('x, 'y) Test.poly = {
  fst: 'x list;
  snd: ('x, 'y) poly option
}

type 'a p' = 'a Test.p' =  A | Bb of 'a p' | Ccccc of 'a 

type p = Test.p

and r = Test.r = { a: int; mutable b: bool; c: p }

type validated_string_check = Test.validated_string_check

type validate_me = Test.validate_me

type val1 = Test.val1 = { val1_x: int }

type val2 = Test.val2 = { val2_x: val1; val2_y: val1 option }

type unixtime_list = Test.unixtime_list

type date = Test.date

type mixed_record = Test.mixed_record = {
  field0: int option;
  field1: float option;
  field2: string option;
  field3: Int64.t;
  field4: float Atdgen_runtime.Util.ocaml_array;
  field5: bool option;
  field6: string option;
  field7: test_variant;
  field8: string Atdgen_runtime.Util.ocaml_array;
  field9: (int * int * Char.t * int * Int32.t * Int64.t);
  field10: bool;
  field11: bool;
  field12: unit list;
  field13: string option list;
  field14: date
}

type mixed = Test.mixed

type test = Test.test = {
  x0: int option;
  x1: float option;
  x2: mixed;
  x3: mixed_record list;
  x4: Int64.t
}

type tup = Test.tup

type star_rating = Test.star_rating

type 'a generic = 'a Test.generic = { x294623: int }

type specialized = Test.specialized

type some_record = Test.some_record = { some_field: int }

type precision = Test.precision = {
  sqrt2_5: float;
  small_2: float;
  large_2: float
}

type p'' = Test.p''

type option_validation = Test.option_validation

type no_real_wrap = Test.no_real_wrap

type natural = Test.natural

type id = Test.id

type json_map = Test.json_map

type intopt = Test.intopt

type int_assoc_list = Test.int_assoc_list

type int_assoc_array = Test.int_assoc_array

type int8 = Test.int8

type int64 = Test.int64

type int32 = Test.int32

type hello = Test.hello

type floats = Test.floats = { f32: float; f64: float }

type extended_tuple = Test.extended_tuple

type extended = Test.extended = {
  b0x (*atd b0 *): int;
  b1x (*atd b1 *): bool;
  b2x (*atd b2 *): string;
  b3x (*atd b3 *): string option;
  b4x (*atd b4 *): string option;
  b5x (*atd b5 *): float
}

type even_natural = Test.even_natural

(**
  \}\}\}abc[def]ghi
  
{v
j  *  j
 k * k
  l*l
v}
  
{v
mno
v}
  
  [pqr]\{stu\}vwx
  
  yz
  
  [\} \[ \] \{v]
  
{v
\} [x] v\} \{v [ @ 
v}
*)
type def = Test_lib.Json.def

type char = Test.char

type base_tuple = Test.base_tuple

type base = Test.base = { b0: int; b1: bool }

type 'a array = 'a Test.array

type 'a abs3 = 'a Test.abs3

type 'a abs2 = 'a Test.abs2

type 'a abs1 = 'a Test.abs1

val write_test_variant :
  Bi_outbuf.t -> test_variant -> unit
  (** Output a JSON value of type {!test_variant}. *)

val string_of_test_variant :
  ?len:int -> test_variant -> string
  (** Serialize a value of type {!test_variant}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_test_variant :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> test_variant
  (** Input JSON data of type {!test_variant}. *)

val test_variant_of_string :
  string -> test_variant
  (** Deserialize JSON data of type {!test_variant}. *)


val write_poly :
  (Bi_outbuf.t -> 'x -> unit) ->
  (Bi_outbuf.t -> 'y -> unit) ->
  Bi_outbuf.t -> ('x, 'y) poly -> unit
  (** Output a JSON value of type {!poly}. *)

val string_of_poly :
  (Bi_outbuf.t -> 'x -> unit) ->
  (Bi_outbuf.t -> 'y -> unit) ->
  ?len:int -> ('x, 'y) poly -> string
  (** Serialize a value of type {!poly}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_poly :
  (Yojson.Safe.lexer_state -> Lexing.lexbuf -> 'x) ->
  (Yojson.Safe.lexer_state -> Lexing.lexbuf -> 'y) ->
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> ('x, 'y) poly
  (** Input JSON data of type {!poly}. *)

val poly_of_string :
  (Yojson.Safe.lexer_state -> Lexing.lexbuf -> 'x) ->
  (Yojson.Safe.lexer_state -> Lexing.lexbuf -> 'y) ->
  string -> ('x, 'y) poly
  (** Deserialize JSON data of type {!poly}. *)

val create_poly :
  fst: 'x list ->
  snd: ('x, 'y) poly option ->
  unit -> ('x, 'y) poly
  (** Create a record of type {!poly}. *)


val write_p' :
  (Bi_outbuf.t -> 'a -> unit) ->
  Bi_outbuf.t -> 'a p' -> unit
  (** Output a JSON value of type {!p'}. *)

val string_of_p' :
  (Bi_outbuf.t -> 'a -> unit) ->
  ?len:int -> 'a p' -> string
  (** Serialize a value of type {!p'}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_p' :
  (Yojson.Safe.lexer_state -> Lexing.lexbuf -> 'a) ->
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> 'a p'
  (** Input JSON data of type {!p'}. *)

val p'_of_string :
  (Yojson.Safe.lexer_state -> Lexing.lexbuf -> 'a) ->
  string -> 'a p'
  (** Deserialize JSON data of type {!p'}. *)


val write_p :
  Bi_outbuf.t -> p -> unit
  (** Output a JSON value of type {!p}. *)

val string_of_p :
  ?len:int -> p -> string
  (** Serialize a value of type {!p}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_p :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> p
  (** Input JSON data of type {!p}. *)

val p_of_string :
  string -> p
  (** Deserialize JSON data of type {!p}. *)


val write_r :
  Bi_outbuf.t -> r -> unit
  (** Output a JSON value of type {!r}. *)

val string_of_r :
  ?len:int -> r -> string
  (** Serialize a value of type {!r}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_r :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> r
  (** Input JSON data of type {!r}. *)

val r_of_string :
  string -> r
  (** Deserialize JSON data of type {!r}. *)

val create_r :
  a: int ->
  b: bool ->
  c: p ->
  unit -> r
  (** Create a record of type {!r}. *)


val write_validated_string_check :
  Bi_outbuf.t -> validated_string_check -> unit
  (** Output a JSON value of type {!validated_string_check}. *)

val string_of_validated_string_check :
  ?len:int -> validated_string_check -> string
  (** Serialize a value of type {!validated_string_check}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_validated_string_check :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> validated_string_check
  (** Input JSON data of type {!validated_string_check}. *)

val validated_string_check_of_string :
  string -> validated_string_check
  (** Deserialize JSON data of type {!validated_string_check}. *)


val write_validate_me :
  Bi_outbuf.t -> validate_me -> unit
  (** Output a JSON value of type {!validate_me}. *)

val string_of_validate_me :
  ?len:int -> validate_me -> string
  (** Serialize a value of type {!validate_me}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_validate_me :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> validate_me
  (** Input JSON data of type {!validate_me}. *)

val validate_me_of_string :
  string -> validate_me
  (** Deserialize JSON data of type {!validate_me}. *)


val write_val1 :
  Bi_outbuf.t -> val1 -> unit
  (** Output a JSON value of type {!val1}. *)

val string_of_val1 :
  ?len:int -> val1 -> string
  (** Serialize a value of type {!val1}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_val1 :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> val1
  (** Input JSON data of type {!val1}. *)

val val1_of_string :
  string -> val1
  (** Deserialize JSON data of type {!val1}. *)

val create_val1 :
  val1_x: int ->
  unit -> val1
  (** Create a record of type {!val1}. *)


val write_val2 :
  Bi_outbuf.t -> val2 -> unit
  (** Output a JSON value of type {!val2}. *)

val string_of_val2 :
  ?len:int -> val2 -> string
  (** Serialize a value of type {!val2}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_val2 :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> val2
  (** Input JSON data of type {!val2}. *)

val val2_of_string :
  string -> val2
  (** Deserialize JSON data of type {!val2}. *)

val create_val2 :
  val2_x: val1 ->
  ?val2_y: val1 ->
  unit -> val2
  (** Create a record of type {!val2}. *)


val write_unixtime_list :
  Bi_outbuf.t -> unixtime_list -> unit
  (** Output a JSON value of type {!unixtime_list}. *)

val string_of_unixtime_list :
  ?len:int -> unixtime_list -> string
  (** Serialize a value of type {!unixtime_list}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_unixtime_list :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> unixtime_list
  (** Input JSON data of type {!unixtime_list}. *)

val unixtime_list_of_string :
  string -> unixtime_list
  (** Deserialize JSON data of type {!unixtime_list}. *)


val write_date :
  Bi_outbuf.t -> date -> unit
  (** Output a JSON value of type {!date}. *)

val string_of_date :
  ?len:int -> date -> string
  (** Serialize a value of type {!date}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_date :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> date
  (** Input JSON data of type {!date}. *)

val date_of_string :
  string -> date
  (** Deserialize JSON data of type {!date}. *)


val write_mixed_record :
  Bi_outbuf.t -> mixed_record -> unit
  (** Output a JSON value of type {!mixed_record}. *)

val string_of_mixed_record :
  ?len:int -> mixed_record -> string
  (** Serialize a value of type {!mixed_record}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_mixed_record :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> mixed_record
  (** Input JSON data of type {!mixed_record}. *)

val mixed_record_of_string :
  string -> mixed_record
  (** Deserialize JSON data of type {!mixed_record}. *)

val create_mixed_record :
  ?field0: int ->
  ?field1: float ->
  field2: string option ->
  field3: Int64.t ->
  field4: float Atdgen_runtime.Util.ocaml_array ->
  ?field5: bool ->
  ?field6: string ->
  field7: test_variant ->
  field8: string Atdgen_runtime.Util.ocaml_array ->
  field9: (int * int * Char.t * int * Int32.t * Int64.t) ->
  field10: bool ->
  ?field11: bool ->
  field12: unit list ->
  field13: string option list ->
  field14: date ->
  unit -> mixed_record
  (** Create a record of type {!mixed_record}. *)


val write_mixed :
  Bi_outbuf.t -> mixed -> unit
  (** Output a JSON value of type {!mixed}. *)

val string_of_mixed :
  ?len:int -> mixed -> string
  (** Serialize a value of type {!mixed}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_mixed :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> mixed
  (** Input JSON data of type {!mixed}. *)

val mixed_of_string :
  string -> mixed
  (** Deserialize JSON data of type {!mixed}. *)


val write_test :
  Bi_outbuf.t -> test -> unit
  (** Output a JSON value of type {!test}. *)

val string_of_test :
  ?len:int -> test -> string
  (** Serialize a value of type {!test}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_test :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> test
  (** Input JSON data of type {!test}. *)

val test_of_string :
  string -> test
  (** Deserialize JSON data of type {!test}. *)

val create_test :
  ?x0: int ->
  ?x1: float ->
  x2: mixed ->
  x3: mixed_record list ->
  x4: Int64.t ->
  unit -> test
  (** Create a record of type {!test}. *)


val write_tup :
  Bi_outbuf.t -> tup -> unit
  (** Output a JSON value of type {!tup}. *)

val string_of_tup :
  ?len:int -> tup -> string
  (** Serialize a value of type {!tup}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_tup :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> tup
  (** Input JSON data of type {!tup}. *)

val tup_of_string :
  string -> tup
  (** Deserialize JSON data of type {!tup}. *)


val write_star_rating :
  Bi_outbuf.t -> star_rating -> unit
  (** Output a JSON value of type {!star_rating}. *)

val string_of_star_rating :
  ?len:int -> star_rating -> string
  (** Serialize a value of type {!star_rating}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_star_rating :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> star_rating
  (** Input JSON data of type {!star_rating}. *)

val star_rating_of_string :
  string -> star_rating
  (** Deserialize JSON data of type {!star_rating}. *)


val write_generic :
  (Bi_outbuf.t -> 'a -> unit) ->
  Bi_outbuf.t -> 'a generic -> unit
  (** Output a JSON value of type {!generic}. *)

val string_of_generic :
  (Bi_outbuf.t -> 'a -> unit) ->
  ?len:int -> 'a generic -> string
  (** Serialize a value of type {!generic}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_generic :
  (Yojson.Safe.lexer_state -> Lexing.lexbuf -> 'a) ->
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> 'a generic
  (** Input JSON data of type {!generic}. *)

val generic_of_string :
  (Yojson.Safe.lexer_state -> Lexing.lexbuf -> 'a) ->
  string -> 'a generic
  (** Deserialize JSON data of type {!generic}. *)

val create_generic :
  x294623: int ->
  unit -> 'a generic
  (** Create a record of type {!generic}. *)


val write_specialized :
  Bi_outbuf.t -> specialized -> unit
  (** Output a JSON value of type {!specialized}. *)

val string_of_specialized :
  ?len:int -> specialized -> string
  (** Serialize a value of type {!specialized}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_specialized :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> specialized
  (** Input JSON data of type {!specialized}. *)

val specialized_of_string :
  string -> specialized
  (** Deserialize JSON data of type {!specialized}. *)


val write_some_record :
  Bi_outbuf.t -> some_record -> unit
  (** Output a JSON value of type {!some_record}. *)

val string_of_some_record :
  ?len:int -> some_record -> string
  (** Serialize a value of type {!some_record}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_some_record :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> some_record
  (** Input JSON data of type {!some_record}. *)

val some_record_of_string :
  string -> some_record
  (** Deserialize JSON data of type {!some_record}. *)

val create_some_record :
  some_field: int ->
  unit -> some_record
  (** Create a record of type {!some_record}. *)


val write_precision :
  Bi_outbuf.t -> precision -> unit
  (** Output a JSON value of type {!precision}. *)

val string_of_precision :
  ?len:int -> precision -> string
  (** Serialize a value of type {!precision}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_precision :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> precision
  (** Input JSON data of type {!precision}. *)

val precision_of_string :
  string -> precision
  (** Deserialize JSON data of type {!precision}. *)

val create_precision :
  sqrt2_5: float ->
  small_2: float ->
  large_2: float ->
  unit -> precision
  (** Create a record of type {!precision}. *)


val write_p'' :
  Bi_outbuf.t -> p'' -> unit
  (** Output a JSON value of type {!p''}. *)

val string_of_p'' :
  ?len:int -> p'' -> string
  (** Serialize a value of type {!p''}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_p'' :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> p''
  (** Input JSON data of type {!p''}. *)

val p''_of_string :
  string -> p''
  (** Deserialize JSON data of type {!p''}. *)


val write_option_validation :
  Bi_outbuf.t -> option_validation -> unit
  (** Output a JSON value of type {!option_validation}. *)

val string_of_option_validation :
  ?len:int -> option_validation -> string
  (** Serialize a value of type {!option_validation}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_option_validation :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> option_validation
  (** Input JSON data of type {!option_validation}. *)

val option_validation_of_string :
  string -> option_validation
  (** Deserialize JSON data of type {!option_validation}. *)


val write_no_real_wrap :
  Bi_outbuf.t -> no_real_wrap -> unit
  (** Output a JSON value of type {!no_real_wrap}. *)

val string_of_no_real_wrap :
  ?len:int -> no_real_wrap -> string
  (** Serialize a value of type {!no_real_wrap}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_no_real_wrap :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> no_real_wrap
  (** Input JSON data of type {!no_real_wrap}. *)

val no_real_wrap_of_string :
  string -> no_real_wrap
  (** Deserialize JSON data of type {!no_real_wrap}. *)


val write_natural :
  Bi_outbuf.t -> natural -> unit
  (** Output a JSON value of type {!natural}. *)

val string_of_natural :
  ?len:int -> natural -> string
  (** Serialize a value of type {!natural}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_natural :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> natural
  (** Input JSON data of type {!natural}. *)

val natural_of_string :
  string -> natural
  (** Deserialize JSON data of type {!natural}. *)


val write_id :
  Bi_outbuf.t -> id -> unit
  (** Output a JSON value of type {!id}. *)

val string_of_id :
  ?len:int -> id -> string
  (** Serialize a value of type {!id}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_id :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> id
  (** Input JSON data of type {!id}. *)

val id_of_string :
  string -> id
  (** Deserialize JSON data of type {!id}. *)


val write_json_map :
  Bi_outbuf.t -> json_map -> unit
  (** Output a JSON value of type {!json_map}. *)

val string_of_json_map :
  ?len:int -> json_map -> string
  (** Serialize a value of type {!json_map}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_json_map :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> json_map
  (** Input JSON data of type {!json_map}. *)

val json_map_of_string :
  string -> json_map
  (** Deserialize JSON data of type {!json_map}. *)


val write_intopt :
  Bi_outbuf.t -> intopt -> unit
  (** Output a JSON value of type {!intopt}. *)

val string_of_intopt :
  ?len:int -> intopt -> string
  (** Serialize a value of type {!intopt}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_intopt :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> intopt
  (** Input JSON data of type {!intopt}. *)

val intopt_of_string :
  string -> intopt
  (** Deserialize JSON data of type {!intopt}. *)


val write_int_assoc_list :
  Bi_outbuf.t -> int_assoc_list -> unit
  (** Output a JSON value of type {!int_assoc_list}. *)

val string_of_int_assoc_list :
  ?len:int -> int_assoc_list -> string
  (** Serialize a value of type {!int_assoc_list}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_int_assoc_list :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> int_assoc_list
  (** Input JSON data of type {!int_assoc_list}. *)

val int_assoc_list_of_string :
  string -> int_assoc_list
  (** Deserialize JSON data of type {!int_assoc_list}. *)


val write_int_assoc_array :
  Bi_outbuf.t -> int_assoc_array -> unit
  (** Output a JSON value of type {!int_assoc_array}. *)

val string_of_int_assoc_array :
  ?len:int -> int_assoc_array -> string
  (** Serialize a value of type {!int_assoc_array}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_int_assoc_array :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> int_assoc_array
  (** Input JSON data of type {!int_assoc_array}. *)

val int_assoc_array_of_string :
  string -> int_assoc_array
  (** Deserialize JSON data of type {!int_assoc_array}. *)


val write_int8 :
  Bi_outbuf.t -> int8 -> unit
  (** Output a JSON value of type {!int8}. *)

val string_of_int8 :
  ?len:int -> int8 -> string
  (** Serialize a value of type {!int8}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_int8 :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> int8
  (** Input JSON data of type {!int8}. *)

val int8_of_string :
  string -> int8
  (** Deserialize JSON data of type {!int8}. *)


val write_int64 :
  Bi_outbuf.t -> int64 -> unit
  (** Output a JSON value of type {!int64}. *)

val string_of_int64 :
  ?len:int -> int64 -> string
  (** Serialize a value of type {!int64}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_int64 :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> int64
  (** Input JSON data of type {!int64}. *)

val int64_of_string :
  string -> int64
  (** Deserialize JSON data of type {!int64}. *)


val write_int32 :
  Bi_outbuf.t -> int32 -> unit
  (** Output a JSON value of type {!int32}. *)

val string_of_int32 :
  ?len:int -> int32 -> string
  (** Serialize a value of type {!int32}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_int32 :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> int32
  (** Input JSON data of type {!int32}. *)

val int32_of_string :
  string -> int32
  (** Deserialize JSON data of type {!int32}. *)


val write_hello :
  Bi_outbuf.t -> hello -> unit
  (** Output a JSON value of type {!hello}. *)

val string_of_hello :
  ?len:int -> hello -> string
  (** Serialize a value of type {!hello}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_hello :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> hello
  (** Input JSON data of type {!hello}. *)

val hello_of_string :
  string -> hello
  (** Deserialize JSON data of type {!hello}. *)


val write_floats :
  Bi_outbuf.t -> floats -> unit
  (** Output a JSON value of type {!floats}. *)

val string_of_floats :
  ?len:int -> floats -> string
  (** Serialize a value of type {!floats}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_floats :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> floats
  (** Input JSON data of type {!floats}. *)

val floats_of_string :
  string -> floats
  (** Deserialize JSON data of type {!floats}. *)

val create_floats :
  f32: float ->
  f64: float ->
  unit -> floats
  (** Create a record of type {!floats}. *)


val write_extended_tuple :
  Bi_outbuf.t -> extended_tuple -> unit
  (** Output a JSON value of type {!extended_tuple}. *)

val string_of_extended_tuple :
  ?len:int -> extended_tuple -> string
  (** Serialize a value of type {!extended_tuple}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_extended_tuple :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> extended_tuple
  (** Input JSON data of type {!extended_tuple}. *)

val extended_tuple_of_string :
  string -> extended_tuple
  (** Deserialize JSON data of type {!extended_tuple}. *)


val write_extended :
  Bi_outbuf.t -> extended -> unit
  (** Output a JSON value of type {!extended}. *)

val string_of_extended :
  ?len:int -> extended -> string
  (** Serialize a value of type {!extended}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_extended :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> extended
  (** Input JSON data of type {!extended}. *)

val extended_of_string :
  string -> extended
  (** Deserialize JSON data of type {!extended}. *)

val create_extended :
  b0x: int ->
  b1x: bool ->
  b2x: string ->
  ?b3x: string ->
  b4x: string option ->
  ?b5x: float ->
  unit -> extended
  (** Create a record of type {!extended}. *)


val write_even_natural :
  Bi_outbuf.t -> even_natural -> unit
  (** Output a JSON value of type {!even_natural}. *)

val string_of_even_natural :
  ?len:int -> even_natural -> string
  (** Serialize a value of type {!even_natural}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_even_natural :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> even_natural
  (** Input JSON data of type {!even_natural}. *)

val even_natural_of_string :
  string -> even_natural
  (** Deserialize JSON data of type {!even_natural}. *)


val write_def :
  Bi_outbuf.t -> def -> unit
  (** Output a JSON value of type {!def}. *)

val string_of_def :
  ?len:int -> def -> string
  (** Serialize a value of type {!def}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_def :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> def
  (** Input JSON data of type {!def}. *)

val def_of_string :
  string -> def
  (** Deserialize JSON data of type {!def}. *)


val write_char :
  Bi_outbuf.t -> char -> unit
  (** Output a JSON value of type {!char}. *)

val string_of_char :
  ?len:int -> char -> string
  (** Serialize a value of type {!char}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_char :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> char
  (** Input JSON data of type {!char}. *)

val char_of_string :
  string -> char
  (** Deserialize JSON data of type {!char}. *)


val write_base_tuple :
  Bi_outbuf.t -> base_tuple -> unit
  (** Output a JSON value of type {!base_tuple}. *)

val string_of_base_tuple :
  ?len:int -> base_tuple -> string
  (** Serialize a value of type {!base_tuple}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_base_tuple :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> base_tuple
  (** Input JSON data of type {!base_tuple}. *)

val base_tuple_of_string :
  string -> base_tuple
  (** Deserialize JSON data of type {!base_tuple}. *)


val write_base :
  Bi_outbuf.t -> base -> unit
  (** Output a JSON value of type {!base}. *)

val string_of_base :
  ?len:int -> base -> string
  (** Serialize a value of type {!base}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_base :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> base
  (** Input JSON data of type {!base}. *)

val base_of_string :
  string -> base
  (** Deserialize JSON data of type {!base}. *)

val create_base :
  b0: int ->
  b1: bool ->
  unit -> base
  (** Create a record of type {!base}. *)


val write_array :
  (Bi_outbuf.t -> 'a -> unit) ->
  Bi_outbuf.t -> 'a array -> unit
  (** Output a JSON value of type {!array}. *)

val string_of_array :
  (Bi_outbuf.t -> 'a -> unit) ->
  ?len:int -> 'a array -> string
  (** Serialize a value of type {!array}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_array :
  (Yojson.Safe.lexer_state -> Lexing.lexbuf -> 'a) ->
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> 'a array
  (** Input JSON data of type {!array}. *)

val array_of_string :
  (Yojson.Safe.lexer_state -> Lexing.lexbuf -> 'a) ->
  string -> 'a array
  (** Deserialize JSON data of type {!array}. *)


val write_abs3 :
  (Bi_outbuf.t -> 'a -> unit) ->
  Bi_outbuf.t -> 'a abs3 -> unit
  (** Output a JSON value of type {!abs3}. *)

val string_of_abs3 :
  (Bi_outbuf.t -> 'a -> unit) ->
  ?len:int -> 'a abs3 -> string
  (** Serialize a value of type {!abs3}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_abs3 :
  (Yojson.Safe.lexer_state -> Lexing.lexbuf -> 'a) ->
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> 'a abs3
  (** Input JSON data of type {!abs3}. *)

val abs3_of_string :
  (Yojson.Safe.lexer_state -> Lexing.lexbuf -> 'a) ->
  string -> 'a abs3
  (** Deserialize JSON data of type {!abs3}. *)


val write_abs2 :
  (Bi_outbuf.t -> 'a -> unit) ->
  Bi_outbuf.t -> 'a abs2 -> unit
  (** Output a JSON value of type {!abs2}. *)

val string_of_abs2 :
  (Bi_outbuf.t -> 'a -> unit) ->
  ?len:int -> 'a abs2 -> string
  (** Serialize a value of type {!abs2}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_abs2 :
  (Yojson.Safe.lexer_state -> Lexing.lexbuf -> 'a) ->
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> 'a abs2
  (** Input JSON data of type {!abs2}. *)

val abs2_of_string :
  (Yojson.Safe.lexer_state -> Lexing.lexbuf -> 'a) ->
  string -> 'a abs2
  (** Deserialize JSON data of type {!abs2}. *)


val write_abs1 :
  (Bi_outbuf.t -> 'a -> unit) ->
  Bi_outbuf.t -> 'a abs1 -> unit
  (** Output a JSON value of type {!abs1}. *)

val string_of_abs1 :
  (Bi_outbuf.t -> 'a -> unit) ->
  ?len:int -> 'a abs1 -> string
  (** Serialize a value of type {!abs1}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_abs1 :
  (Yojson.Safe.lexer_state -> Lexing.lexbuf -> 'a) ->
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> 'a abs1
  (** Input JSON data of type {!abs1}. *)

val abs1_of_string :
  (Yojson.Safe.lexer_state -> Lexing.lexbuf -> 'a) ->
  string -> 'a abs1
  (** Deserialize JSON data of type {!abs1}. *)


atd-2.1.0/atdgen/test/testjstd.expected.ml000066400000000000000000004161751357165332000205240ustar00rootroot00000000000000(* Auto-generated from "test.atd" *)
[@@@ocaml.warning "-27-32-35-39"]

(** This is just a test. *)

type test_variant = Test.test_variant

type ('x, 'y) poly = ('x, 'y) Test.poly = {
  fst: 'x list;
  snd: ('x, 'y) poly option
}

type 'a p' = 'a Test.p' =  A | Bb of 'a p' | Ccccc of 'a 

type p = Test.p

and r = Test.r = { a: int; mutable b: bool; c: p }

type validated_string_check = Test.validated_string_check

type validate_me = Test.validate_me

type val1 = Test.val1 = { val1_x: int }

type val2 = Test.val2 = { val2_x: val1; val2_y: val1 option }

type unixtime_list = Test.unixtime_list

type date = Test.date

type mixed_record = Test.mixed_record = {
  field0: int option;
  field1: float option;
  field2: string option;
  field3: Int64.t;
  field4: float Atdgen_runtime.Util.ocaml_array;
  field5: bool option;
  field6: string option;
  field7: test_variant;
  field8: string Atdgen_runtime.Util.ocaml_array;
  field9: (int * int * Char.t * int * Int32.t * Int64.t);
  field10: bool;
  field11: bool;
  field12: unit list;
  field13: string option list;
  field14: date
}

type mixed = Test.mixed

type test = Test.test = {
  x0: int option;
  x1: float option;
  x2: mixed;
  x3: mixed_record list;
  x4: Int64.t
}

type tup = Test.tup

type star_rating = Test.star_rating

type 'a generic = 'a Test.generic = { x294623: int }

type specialized = Test.specialized

type some_record = Test.some_record = { some_field: int }

type precision = Test.precision = {
  sqrt2_5: float;
  small_2: float;
  large_2: float
}

type p'' = Test.p''

type option_validation = Test.option_validation

type no_real_wrap = Test.no_real_wrap

type natural = Test.natural

type id = Test.id

type json_map = Test.json_map

type intopt = Test.intopt

type int_assoc_list = Test.int_assoc_list

type int_assoc_array = Test.int_assoc_array

type int8 = Test.int8

type int64 = Test.int64

type int32 = Test.int32

type hello = Test.hello

type floats = Test.floats = { f32: float; f64: float }

type extended_tuple = Test.extended_tuple

type extended = Test.extended = {
  b0x (*atd b0 *): int;
  b1x (*atd b1 *): bool;
  b2x (*atd b2 *): string;
  b3x (*atd b3 *): string option;
  b4x (*atd b4 *): string option;
  b5x (*atd b5 *): float
}

type even_natural = Test.even_natural

(**
  \}\}\}abc[def]ghi
  
{v
j  *  j
 k * k
  l*l
v}
  
{v
mno
v}
  
  [pqr]\{stu\}vwx
  
  yz
  
  [\} \[ \] \{v]
  
{v
\} [x] v\} \{v [ @ 
v}
*)
type def = Test_lib.Json.def

type char = Test.char

type base_tuple = Test.base_tuple

type base = Test.base = { b0: int; b1: bool }

type 'a array = 'a Test.array

type 'a abs3 = 'a Test.abs3

type 'a abs2 = 'a Test.abs2

type 'a abs1 = 'a Test.abs1

let write__19 write__a = (
  Atdgen_runtime.Oj_run.write_list (
    write__a
  )
)
let string_of__19 write__a ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__19 write__a ob x;
  Bi_outbuf.contents ob
let read__19 read__a = (
  Atdgen_runtime.Oj_run.read_list (
    read__a
  )
)
let _19_of_string read__a s =
  read__19 read__a (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let rec write_p' write__a : _ -> 'a p' -> _ = (
  fun ob x ->
    match x with
      | A -> Bi_outbuf.add_string ob "\"A\""
      | Bb x ->
        Bi_outbuf.add_string ob "[\"Bb\",";
        (
          write_p' write__a
        ) ob x;
        Bi_outbuf.add_char ob ']'
      | Ccccc x ->
        Bi_outbuf.add_string ob "[\"Ccccc\",";
        (
          write__a
        ) ob x;
        Bi_outbuf.add_char ob ']'
)
and string_of_p' write__a ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_p' write__a ob x;
  Bi_outbuf.contents ob
let rec read_p' read__a = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    match Yojson.Safe.start_any_variant p lb with
      | `Edgy_bracket -> (
          match Yojson.Safe.read_ident p lb with
            | "A" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              (A : 'a p')
            | "Bb" ->
              Atdgen_runtime.Oj_run.read_until_field_value p lb;
              let x = (
                  read_p' read__a
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              (Bb x : 'a p')
            | "Ccccc" ->
              Atdgen_runtime.Oj_run.read_until_field_value p lb;
              let x = (
                  read__a
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              (Ccccc x : 'a p')
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Double_quote -> (
          match Yojson.Safe.finish_string p lb with
            | "A" ->
              (A : 'a p')
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Square_bracket -> (
          match Atdgen_runtime.Oj_run.read_string p lb with
            | "Bb" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_comma p lb;
              Yojson.Safe.read_space p lb;
              let x = (
                  read_p' read__a
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_rbr p lb;
              (Bb x : 'a p')
            | "Ccccc" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_comma p lb;
              Yojson.Safe.read_space p lb;
              let x = (
                  read__a
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_rbr p lb;
              (Ccccc x : 'a p')
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
)
and p'_of_string read__a s =
  read_p' read__a (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let rec write_p = (
  fun ob x ->
    match x with
      | `A -> Bi_outbuf.add_string ob "\"A\""
      | `B x ->
        Bi_outbuf.add_string ob "[\"B\",";
        (
          write_r
        ) ob x;
        Bi_outbuf.add_char ob ']'
      | `C -> Bi_outbuf.add_string ob "\"C\""
)
and string_of_p ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_p ob x;
  Bi_outbuf.contents ob
and write_r : _ -> r -> _ = (
  fun ob (x : r) ->
    Bi_outbuf.add_char ob '{';
    let is_first = ref true in
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"a\":";
    (
      Yojson.Safe.write_int
    )
      ob x.a;
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"b\":";
    (
      Yojson.Safe.write_bool
    )
      ob x.b;
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"c\":";
    (
      write_p
    )
      ob x.c;
    Bi_outbuf.add_char ob '}';
)
and string_of_r ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_r ob x;
  Bi_outbuf.contents ob
let rec read_p = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    match Yojson.Safe.start_any_variant p lb with
      | `Edgy_bracket -> (
          match Yojson.Safe.read_ident p lb with
            | "A" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              `A
            | "B" ->
              Atdgen_runtime.Oj_run.read_until_field_value p lb;
              let x = (
                  read_r
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              `B x
            | "C" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              `C
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Double_quote -> (
          match Yojson.Safe.finish_string p lb with
            | "A" ->
              `A
            | "C" ->
              `C
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Square_bracket -> (
          match Atdgen_runtime.Oj_run.read_string p lb with
            | "B" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_comma p lb;
              Yojson.Safe.read_space p lb;
              let x = (
                  read_r
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_rbr p lb;
              `B x
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
)
and p_of_string s =
  read_p (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
and read_r = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    Yojson.Safe.read_lcurl p lb;
    let field_a = ref (None) in
    let field_b = ref (None) in
    let field_c = ref (None) in
    try
      Yojson.Safe.read_space p lb;
      Yojson.Safe.read_object_end lb;
      Yojson.Safe.read_space p lb;
      let f =
        fun s pos len ->
          if pos < 0 || len < 0 || pos + len > String.length s then
            invalid_arg "out-of-bounds substring position or length";
          if len = 1 then (
            match String.unsafe_get s pos with
              | 'a' -> (
                  0
                )
              | 'b' -> (
                  1
                )
              | 'c' -> (
                  2
                )
              | _ -> (
                  -1
                )
          )
          else (
            -1
          )
      in
      let i = Yojson.Safe.map_ident p f lb in
      Atdgen_runtime.Oj_run.read_until_field_value p lb;
      (
        match i with
          | 0 ->
            field_a := (
              Some (
                (
                  Atdgen_runtime.Oj_run.read_int
                ) p lb
              )
            );
          | 1 ->
            field_b := (
              Some (
                (
                  Atdgen_runtime.Oj_run.read_bool
                ) p lb
              )
            );
          | 2 ->
            field_c := (
              Some (
                (
                  read_p
                ) p lb
              )
            );
          | _ -> (
              Yojson.Safe.skip_json p lb
            )
      );
      while true do
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_object_sep p lb;
        Yojson.Safe.read_space p lb;
        let f =
          fun s pos len ->
            if pos < 0 || len < 0 || pos + len > String.length s then
              invalid_arg "out-of-bounds substring position or length";
            if len = 1 then (
              match String.unsafe_get s pos with
                | 'a' -> (
                    0
                  )
                | 'b' -> (
                    1
                  )
                | 'c' -> (
                    2
                  )
                | _ -> (
                    -1
                  )
            )
            else (
              -1
            )
        in
        let i = Yojson.Safe.map_ident p f lb in
        Atdgen_runtime.Oj_run.read_until_field_value p lb;
        (
          match i with
            | 0 ->
              field_a := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_int
                  ) p lb
                )
              );
            | 1 ->
              field_b := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_bool
                  ) p lb
                )
              );
            | 2 ->
              field_c := (
                Some (
                  (
                    read_p
                  ) p lb
                )
              );
            | _ -> (
                Yojson.Safe.skip_json p lb
              )
        );
      done;
      assert false;
    with Yojson.End_of_object -> (
        (
          {
            a = (match !field_a with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "a");
            b = (match !field_b with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "b");
            c = (match !field_c with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "c");
          }
         : r)
      )
)
and r_of_string s =
  read_r (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let rec write__20 write__a write__b ob x = (
  Atdgen_runtime.Oj_run.write_std_option (
    write_poly write__a write__b
  )
) ob x
and string_of__20 write__a write__b ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__20 write__a write__b ob x;
  Bi_outbuf.contents ob
and write_poly write__x write__y : _ -> ('x, 'y) poly -> _ = (
  fun ob (x : ('x, 'y) poly) ->
    Bi_outbuf.add_char ob '{';
    let is_first = ref true in
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"fst\":";
    (
      write__19 write__x
    )
      ob x.fst;
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"snd\":";
    (
      write__20 write__x write__y
    )
      ob x.snd;
    Bi_outbuf.add_char ob '}';
)
and string_of_poly write__x write__y ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_poly write__x write__y ob x;
  Bi_outbuf.contents ob
let rec read__20 read__a read__b = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    match Yojson.Safe.start_any_variant p lb with
      | `Edgy_bracket -> (
          match Yojson.Safe.read_ident p lb with
            | "None" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              (None : _ option)
            | "Some" ->
              Atdgen_runtime.Oj_run.read_until_field_value p lb;
              let x = (
                  read_poly read__a read__b
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              (Some x : _ option)
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Double_quote -> (
          match Yojson.Safe.finish_string p lb with
            | "None" ->
              (None : _ option)
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Square_bracket -> (
          match Atdgen_runtime.Oj_run.read_string p lb with
            | "Some" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_comma p lb;
              Yojson.Safe.read_space p lb;
              let x = (
                  read_poly read__a read__b
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_rbr p lb;
              (Some x : _ option)
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
)
and _20_of_string read__a read__b s =
  read__20 read__a read__b (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
and read_poly read__x read__y = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    Yojson.Safe.read_lcurl p lb;
    let field_fst = ref (None) in
    let field_snd = ref (None) in
    try
      Yojson.Safe.read_space p lb;
      Yojson.Safe.read_object_end lb;
      Yojson.Safe.read_space p lb;
      let f =
        fun s pos len ->
          if pos < 0 || len < 0 || pos + len > String.length s then
            invalid_arg "out-of-bounds substring position or length";
          if len = 3 then (
            match String.unsafe_get s pos with
              | 'f' -> (
                  if String.unsafe_get s (pos+1) = 's' && String.unsafe_get s (pos+2) = 't' then (
                    0
                  )
                  else (
                    -1
                  )
                )
              | 's' -> (
                  if String.unsafe_get s (pos+1) = 'n' && String.unsafe_get s (pos+2) = 'd' then (
                    1
                  )
                  else (
                    -1
                  )
                )
              | _ -> (
                  -1
                )
          )
          else (
            -1
          )
      in
      let i = Yojson.Safe.map_ident p f lb in
      Atdgen_runtime.Oj_run.read_until_field_value p lb;
      (
        match i with
          | 0 ->
            field_fst := (
              Some (
                (
                  read__19 read__x
                ) p lb
              )
            );
          | 1 ->
            field_snd := (
              Some (
                (
                  read__20 read__x read__y
                ) p lb
              )
            );
          | _ -> (
              Yojson.Safe.skip_json p lb
            )
      );
      while true do
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_object_sep p lb;
        Yojson.Safe.read_space p lb;
        let f =
          fun s pos len ->
            if pos < 0 || len < 0 || pos + len > String.length s then
              invalid_arg "out-of-bounds substring position or length";
            if len = 3 then (
              match String.unsafe_get s pos with
                | 'f' -> (
                    if String.unsafe_get s (pos+1) = 's' && String.unsafe_get s (pos+2) = 't' then (
                      0
                    )
                    else (
                      -1
                    )
                  )
                | 's' -> (
                    if String.unsafe_get s (pos+1) = 'n' && String.unsafe_get s (pos+2) = 'd' then (
                      1
                    )
                    else (
                      -1
                    )
                  )
                | _ -> (
                    -1
                  )
            )
            else (
              -1
            )
        in
        let i = Yojson.Safe.map_ident p f lb in
        Atdgen_runtime.Oj_run.read_until_field_value p lb;
        (
          match i with
            | 0 ->
              field_fst := (
                Some (
                  (
                    read__19 read__x
                  ) p lb
                )
              );
            | 1 ->
              field_snd := (
                Some (
                  (
                    read__20 read__x read__y
                  ) p lb
                )
              );
            | _ -> (
                Yojson.Safe.skip_json p lb
              )
        );
      done;
      assert false;
    with Yojson.End_of_object -> (
        (
          {
            fst = (match !field_fst with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "fst");
            snd = (match !field_snd with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "snd");
          }
         : ('x, 'y) poly)
      )
)
and poly_of_string read__x read__y s =
  read_poly read__x read__y (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let rec write__2 ob x = (
  Atdgen_runtime.Oj_run.write_list (
    write_test_variant
  )
) ob x
and string_of__2 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__2 ob x;
  Bi_outbuf.contents ob
and write_test_variant = (
  fun ob x ->
    match x with
      | `Case1 -> Bi_outbuf.add_string ob "\"Case1\""
      | `Case2 x ->
        Bi_outbuf.add_string ob "[\"Case2\",";
        (
          Yojson.Safe.write_int
        ) ob x;
        Bi_outbuf.add_char ob ']'
      | `Case3 x ->
        Bi_outbuf.add_string ob "[\"Case3\",";
        (
          Yojson.Safe.write_string
        ) ob x;
        Bi_outbuf.add_char ob ']'
      | `Case4 x ->
        Bi_outbuf.add_string ob "[\"Case4\",";
        (
          write__2
        ) ob x;
        Bi_outbuf.add_char ob ']'
)
and string_of_test_variant ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_test_variant ob x;
  Bi_outbuf.contents ob
let rec read__2 p lb = (
  Atdgen_runtime.Oj_run.read_list (
    read_test_variant
  )
) p lb
and _2_of_string s =
  read__2 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
and read_test_variant = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    match Yojson.Safe.start_any_variant p lb with
      | `Edgy_bracket -> (
          match Yojson.Safe.read_ident p lb with
            | "Case1" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              `Case1
            | "Case2" ->
              Atdgen_runtime.Oj_run.read_until_field_value p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_int
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              `Case2 x
            | "Case3" ->
              Atdgen_runtime.Oj_run.read_until_field_value p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_string
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              `Case3 x
            | "Case4" ->
              Atdgen_runtime.Oj_run.read_until_field_value p lb;
              let x = (
                  read__2
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              `Case4 x
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Double_quote -> (
          match Yojson.Safe.finish_string p lb with
            | "Case1" ->
              `Case1
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Square_bracket -> (
          match Atdgen_runtime.Oj_run.read_string p lb with
            | "Case2" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_comma p lb;
              Yojson.Safe.read_space p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_int
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_rbr p lb;
              `Case2 x
            | "Case3" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_comma p lb;
              Yojson.Safe.read_space p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_string
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_rbr p lb;
              `Case3 x
            | "Case4" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_comma p lb;
              Yojson.Safe.read_space p lb;
              let x = (
                  read__2
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_rbr p lb;
              `Case4 x
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
)
and test_variant_of_string s =
  read_test_variant (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let rec write__1 : _ -> _ p' -> _ = (
  fun ob x ->
    match x with
      | A -> Bi_outbuf.add_string ob "\"A\""
      | Bb x ->
        Bi_outbuf.add_string ob "[\"Bb\",";
        (
          write__1
        ) ob x;
        Bi_outbuf.add_char ob ']'
      | Ccccc x ->
        Bi_outbuf.add_string ob "[\"Ccccc\",";
        (
          Yojson.Safe.write_int
        ) ob x;
        Bi_outbuf.add_char ob ']'
)
and string_of__1 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__1 ob x;
  Bi_outbuf.contents ob
let rec read__1 = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    match Yojson.Safe.start_any_variant p lb with
      | `Edgy_bracket -> (
          match Yojson.Safe.read_ident p lb with
            | "A" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              (A : _ p')
            | "Bb" ->
              Atdgen_runtime.Oj_run.read_until_field_value p lb;
              let x = (
                  read__1
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              (Bb x : _ p')
            | "Ccccc" ->
              Atdgen_runtime.Oj_run.read_until_field_value p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_int
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              (Ccccc x : _ p')
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Double_quote -> (
          match Yojson.Safe.finish_string p lb with
            | "A" ->
              (A : _ p')
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Square_bracket -> (
          match Atdgen_runtime.Oj_run.read_string p lb with
            | "Bb" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_comma p lb;
              Yojson.Safe.read_space p lb;
              let x = (
                  read__1
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_rbr p lb;
              (Bb x : _ p')
            | "Ccccc" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_comma p lb;
              Yojson.Safe.read_space p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_int
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_rbr p lb;
              (Ccccc x : _ p')
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
)
and _1_of_string s =
  read__1 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_validated_string_check = (
  Yojson.Safe.write_string
)
let string_of_validated_string_check ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_validated_string_check ob x;
  Bi_outbuf.contents ob
let read_validated_string_check = (
  Atdgen_runtime.Oj_run.read_string
)
let validated_string_check_of_string s =
  read_validated_string_check (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__31 = (
  Atdgen_runtime.Oj_run.write_list (
    Yojson.Safe.write_string
  )
)
let string_of__31 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__31 ob x;
  Bi_outbuf.contents ob
let read__31 = (
  Atdgen_runtime.Oj_run.read_list (
    Atdgen_runtime.Oj_run.read_string
  )
)
let _31_of_string s =
  read__31 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_validate_me = (
  write__31
)
let string_of_validate_me ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_validate_me ob x;
  Bi_outbuf.contents ob
let read_validate_me = (
  read__31
)
let validate_me_of_string s =
  read_validate_me (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_val1 : _ -> val1 -> _ = (
  fun ob (x : val1) ->
    Bi_outbuf.add_char ob '{';
    let is_first = ref true in
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"val1_x\":";
    (
      Yojson.Safe.write_int
    )
      ob x.val1_x;
    Bi_outbuf.add_char ob '}';
)
let string_of_val1 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_val1 ob x;
  Bi_outbuf.contents ob
let read_val1 = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    Yojson.Safe.read_lcurl p lb;
    let field_val1_x = ref (None) in
    try
      Yojson.Safe.read_space p lb;
      Yojson.Safe.read_object_end lb;
      Yojson.Safe.read_space p lb;
      let f =
        fun s pos len ->
          if pos < 0 || len < 0 || pos + len > String.length s then
            invalid_arg "out-of-bounds substring position or length";
          if len = 6 && String.unsafe_get s pos = 'v' && String.unsafe_get s (pos+1) = 'a' && String.unsafe_get s (pos+2) = 'l' && String.unsafe_get s (pos+3) = '1' && String.unsafe_get s (pos+4) = '_' && String.unsafe_get s (pos+5) = 'x' then (
            0
          )
          else (
            -1
          )
      in
      let i = Yojson.Safe.map_ident p f lb in
      Atdgen_runtime.Oj_run.read_until_field_value p lb;
      (
        match i with
          | 0 ->
            field_val1_x := (
              Some (
                (
                  Atdgen_runtime.Oj_run.read_int
                ) p lb
              )
            );
          | _ -> (
              Yojson.Safe.skip_json p lb
            )
      );
      while true do
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_object_sep p lb;
        Yojson.Safe.read_space p lb;
        let f =
          fun s pos len ->
            if pos < 0 || len < 0 || pos + len > String.length s then
              invalid_arg "out-of-bounds substring position or length";
            if len = 6 && String.unsafe_get s pos = 'v' && String.unsafe_get s (pos+1) = 'a' && String.unsafe_get s (pos+2) = 'l' && String.unsafe_get s (pos+3) = '1' && String.unsafe_get s (pos+4) = '_' && String.unsafe_get s (pos+5) = 'x' then (
              0
            )
            else (
              -1
            )
        in
        let i = Yojson.Safe.map_ident p f lb in
        Atdgen_runtime.Oj_run.read_until_field_value p lb;
        (
          match i with
            | 0 ->
              field_val1_x := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_int
                  ) p lb
                )
              );
            | _ -> (
                Yojson.Safe.skip_json p lb
              )
        );
      done;
      assert false;
    with Yojson.End_of_object -> (
        (
          {
            val1_x = (match !field_val1_x with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "val1_x");
          }
         : val1)
      )
)
let val1_of_string s =
  read_val1 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__16 = (
  Atdgen_runtime.Oj_run.write_std_option (
    write_val1
  )
)
let string_of__16 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__16 ob x;
  Bi_outbuf.contents ob
let read__16 = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    match Yojson.Safe.start_any_variant p lb with
      | `Edgy_bracket -> (
          match Yojson.Safe.read_ident p lb with
            | "None" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              (None : _ option)
            | "Some" ->
              Atdgen_runtime.Oj_run.read_until_field_value p lb;
              let x = (
                  read_val1
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              (Some x : _ option)
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Double_quote -> (
          match Yojson.Safe.finish_string p lb with
            | "None" ->
              (None : _ option)
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Square_bracket -> (
          match Atdgen_runtime.Oj_run.read_string p lb with
            | "Some" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_comma p lb;
              Yojson.Safe.read_space p lb;
              let x = (
                  read_val1
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_rbr p lb;
              (Some x : _ option)
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
)
let _16_of_string s =
  read__16 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_val2 : _ -> val2 -> _ = (
  fun ob (x : val2) ->
    Bi_outbuf.add_char ob '{';
    let is_first = ref true in
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"val2_x\":";
    (
      write_val1
    )
      ob x.val2_x;
    (match x.val2_y with None -> () | Some x ->
      if !is_first then
        is_first := false
      else
        Bi_outbuf.add_char ob ',';
      Bi_outbuf.add_string ob "\"val2_y\":";
      (
        write_val1
      )
        ob x;
    );
    Bi_outbuf.add_char ob '}';
)
let string_of_val2 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_val2 ob x;
  Bi_outbuf.contents ob
let read_val2 = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    Yojson.Safe.read_lcurl p lb;
    let field_val2_x = ref (None) in
    let field_val2_y = ref (None) in
    try
      Yojson.Safe.read_space p lb;
      Yojson.Safe.read_object_end lb;
      Yojson.Safe.read_space p lb;
      let f =
        fun s pos len ->
          if pos < 0 || len < 0 || pos + len > String.length s then
            invalid_arg "out-of-bounds substring position or length";
          if len = 6 && String.unsafe_get s pos = 'v' && String.unsafe_get s (pos+1) = 'a' && String.unsafe_get s (pos+2) = 'l' && String.unsafe_get s (pos+3) = '2' && String.unsafe_get s (pos+4) = '_' then (
            match String.unsafe_get s (pos+5) with
              | 'x' -> (
                  0
                )
              | 'y' -> (
                  1
                )
              | _ -> (
                  -1
                )
          )
          else (
            -1
          )
      in
      let i = Yojson.Safe.map_ident p f lb in
      Atdgen_runtime.Oj_run.read_until_field_value p lb;
      (
        match i with
          | 0 ->
            field_val2_x := (
              Some (
                (
                  read_val1
                ) p lb
              )
            );
          | 1 ->
            if not (Yojson.Safe.read_null_if_possible p lb) then (
              field_val2_y := (
                Some (
                  (
                    read_val1
                  ) p lb
                )
              );
            )
          | _ -> (
              Yojson.Safe.skip_json p lb
            )
      );
      while true do
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_object_sep p lb;
        Yojson.Safe.read_space p lb;
        let f =
          fun s pos len ->
            if pos < 0 || len < 0 || pos + len > String.length s then
              invalid_arg "out-of-bounds substring position or length";
            if len = 6 && String.unsafe_get s pos = 'v' && String.unsafe_get s (pos+1) = 'a' && String.unsafe_get s (pos+2) = 'l' && String.unsafe_get s (pos+3) = '2' && String.unsafe_get s (pos+4) = '_' then (
              match String.unsafe_get s (pos+5) with
                | 'x' -> (
                    0
                  )
                | 'y' -> (
                    1
                  )
                | _ -> (
                    -1
                  )
            )
            else (
              -1
            )
        in
        let i = Yojson.Safe.map_ident p f lb in
        Atdgen_runtime.Oj_run.read_until_field_value p lb;
        (
          match i with
            | 0 ->
              field_val2_x := (
                Some (
                  (
                    read_val1
                  ) p lb
                )
              );
            | 1 ->
              if not (Yojson.Safe.read_null_if_possible p lb) then (
                field_val2_y := (
                  Some (
                    (
                      read_val1
                    ) p lb
                  )
                );
              )
            | _ -> (
                Yojson.Safe.skip_json p lb
              )
        );
      done;
      assert false;
    with Yojson.End_of_object -> (
        (
          {
            val2_x = (match !field_val2_x with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "val2_x");
            val2_y = !field_val2_y;
          }
         : val2)
      )
)
let val2_of_string s =
  read_val2 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__29 = (
  Atdgen_runtime.Oj_run.write_list (
    Atdgen_runtime.Oj_run.write_float_as_int
  )
)
let string_of__29 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__29 ob x;
  Bi_outbuf.contents ob
let read__29 = (
  Atdgen_runtime.Oj_run.read_list (
    Atdgen_runtime.Oj_run.read_number
  )
)
let _29_of_string s =
  read__29 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_unixtime_list = (
  write__29
)
let string_of_unixtime_list ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_unixtime_list ob x;
  Bi_outbuf.contents ob
let read_unixtime_list = (
  read__29
)
let unixtime_list_of_string s =
  read_unixtime_list (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__3 = (
  Atdgen_runtime.Oj_run.write_nullable (
    Yojson.Safe.write_int
  )
)
let string_of__3 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__3 ob x;
  Bi_outbuf.contents ob
let read__3 = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    (if Yojson.Safe.read_null_if_possible p lb then None
    else Some ((
      Atdgen_runtime.Oj_run.read_int
    ) p lb) : _ option)
)
let _3_of_string s =
  read__3 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_date = (
  fun ob x ->
    Bi_outbuf.add_char ob '[';
    (let x, _, _ = x in
    (
      Yojson.Safe.write_int
    ) ob x
    );
    Bi_outbuf.add_char ob ',';
    (let _, x, _ = x in
    (
      write__3
    ) ob x
    );
    Bi_outbuf.add_char ob ',';
    (let _, _, x = x in
    (
      write__3
    ) ob x
    );
    Bi_outbuf.add_char ob ']';
)
let string_of_date ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_date ob x;
  Bi_outbuf.contents ob
let read_date = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    let std_tuple = Yojson.Safe.start_any_tuple p lb in
    let len = ref 0 in
    let end_of_tuple = ref false in
    (try
      let x0 =
        let x =
          (
            Atdgen_runtime.Oj_run.read_int
          ) p lb
        in
        incr len;
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_tuple_sep2 p std_tuple lb;
        x
      in
      let x1 =
        let x =
          (
            read__3
          ) p lb
        in
        incr len;
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_tuple_sep2 p std_tuple lb;
        x
      in
      let x2 =
        let x =
          (
            read__3
          ) p lb
        in
        incr len;
        (try
          Yojson.Safe.read_space p lb;
          Yojson.Safe.read_tuple_sep2 p std_tuple lb;
        with Yojson.End_of_tuple -> end_of_tuple := true);
        x
      in
      if not !end_of_tuple then (
        try
          while true do
            Yojson.Safe.skip_json p lb;
            Yojson.Safe.read_space p lb;
            Yojson.Safe.read_tuple_sep2 p std_tuple lb;
          done
        with Yojson.End_of_tuple -> ()
      );
      (x0, x1, x2)
    with Yojson.End_of_tuple ->
      Atdgen_runtime.Oj_run.missing_tuple_fields p !len [ 0; 1; 2 ]);
)
let date_of_string s =
  read_date (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__9 = (
  Atdgen_runtime.Oj_run.write_array (
    Yojson.Safe.write_string
  )
)
let string_of__9 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__9 ob x;
  Bi_outbuf.contents ob
let read__9 = (
  Atdgen_runtime.Oj_run.read_array (
    Atdgen_runtime.Oj_run.read_string
  )
)
let _9_of_string s =
  read__9 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__8 = (
  Atdgen_runtime.Oj_run.write_std_option (
    Yojson.Safe.write_bool
  )
)
let string_of__8 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__8 ob x;
  Bi_outbuf.contents ob
let read__8 = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    match Yojson.Safe.start_any_variant p lb with
      | `Edgy_bracket -> (
          match Yojson.Safe.read_ident p lb with
            | "None" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              (None : _ option)
            | "Some" ->
              Atdgen_runtime.Oj_run.read_until_field_value p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_bool
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              (Some x : _ option)
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Double_quote -> (
          match Yojson.Safe.finish_string p lb with
            | "None" ->
              (None : _ option)
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Square_bracket -> (
          match Atdgen_runtime.Oj_run.read_string p lb with
            | "Some" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_comma p lb;
              Yojson.Safe.read_space p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_bool
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_rbr p lb;
              (Some x : _ option)
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
)
let _8_of_string s =
  read__8 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__7 = (
  Atdgen_runtime.Oj_run.write_array (
    Yojson.Safe.write_std_float
  )
)
let string_of__7 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__7 ob x;
  Bi_outbuf.contents ob
let read__7 = (
  Atdgen_runtime.Oj_run.read_array (
    Atdgen_runtime.Oj_run.read_number
  )
)
let _7_of_string s =
  read__7 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__6 = (
  Atdgen_runtime.Oj_run.write_std_option (
    Yojson.Safe.write_string
  )
)
let string_of__6 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__6 ob x;
  Bi_outbuf.contents ob
let read__6 = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    match Yojson.Safe.start_any_variant p lb with
      | `Edgy_bracket -> (
          match Yojson.Safe.read_ident p lb with
            | "None" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              (None : _ option)
            | "Some" ->
              Atdgen_runtime.Oj_run.read_until_field_value p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_string
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              (Some x : _ option)
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Double_quote -> (
          match Yojson.Safe.finish_string p lb with
            | "None" ->
              (None : _ option)
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Square_bracket -> (
          match Atdgen_runtime.Oj_run.read_string p lb with
            | "Some" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_comma p lb;
              Yojson.Safe.read_space p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_string
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_rbr p lb;
              (Some x : _ option)
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
)
let _6_of_string s =
  read__6 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__5 = (
  Atdgen_runtime.Oj_run.write_std_option (
    Yojson.Safe.write_std_float
  )
)
let string_of__5 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__5 ob x;
  Bi_outbuf.contents ob
let read__5 = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    match Yojson.Safe.start_any_variant p lb with
      | `Edgy_bracket -> (
          match Yojson.Safe.read_ident p lb with
            | "None" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              (None : _ option)
            | "Some" ->
              Atdgen_runtime.Oj_run.read_until_field_value p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_number
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              (Some x : _ option)
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Double_quote -> (
          match Yojson.Safe.finish_string p lb with
            | "None" ->
              (None : _ option)
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Square_bracket -> (
          match Atdgen_runtime.Oj_run.read_string p lb with
            | "Some" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_comma p lb;
              Yojson.Safe.read_space p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_number
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_rbr p lb;
              (Some x : _ option)
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
)
let _5_of_string s =
  read__5 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__4 = (
  Atdgen_runtime.Oj_run.write_std_option (
    Yojson.Safe.write_int
  )
)
let string_of__4 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__4 ob x;
  Bi_outbuf.contents ob
let read__4 = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    match Yojson.Safe.start_any_variant p lb with
      | `Edgy_bracket -> (
          match Yojson.Safe.read_ident p lb with
            | "None" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              (None : _ option)
            | "Some" ->
              Atdgen_runtime.Oj_run.read_until_field_value p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_int
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              (Some x : _ option)
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Double_quote -> (
          match Yojson.Safe.finish_string p lb with
            | "None" ->
              (None : _ option)
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Square_bracket -> (
          match Atdgen_runtime.Oj_run.read_string p lb with
            | "Some" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_comma p lb;
              Yojson.Safe.read_space p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_int
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_rbr p lb;
              (Some x : _ option)
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
)
let _4_of_string s =
  read__4 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__11 = (
  Atdgen_runtime.Oj_run.write_list (
    write__6
  )
)
let string_of__11 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__11 ob x;
  Bi_outbuf.contents ob
let read__11 = (
  Atdgen_runtime.Oj_run.read_list (
    read__6
  )
)
let _11_of_string s =
  read__11 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__10 = (
  Atdgen_runtime.Oj_run.write_list (
    Yojson.Safe.write_null
  )
)
let string_of__10 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__10 ob x;
  Bi_outbuf.contents ob
let read__10 = (
  Atdgen_runtime.Oj_run.read_list (
    Atdgen_runtime.Oj_run.read_null
  )
)
let _10_of_string s =
  read__10 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_mixed_record : _ -> mixed_record -> _ = (
  fun ob (x : mixed_record) ->
    Bi_outbuf.add_char ob '{';
    let is_first = ref true in
    (match x.field0 with None -> () | Some x ->
      if !is_first then
        is_first := false
      else
        Bi_outbuf.add_char ob ',';
      Bi_outbuf.add_string ob "\"field0\":";
      (
        Yojson.Safe.write_int
      )
        ob x;
    );
    (match x.field1 with None -> () | Some x ->
      if !is_first then
        is_first := false
      else
        Bi_outbuf.add_char ob ',';
      Bi_outbuf.add_string ob "\"field1\":";
      (
        Yojson.Safe.write_std_float
      )
        ob x;
    );
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"field2\":";
    (
      write__6
    )
      ob x.field2;
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"field3\":";
    (
      Atdgen_runtime.Oj_run.write_int64
    )
      ob x.field3;
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"field4\":";
    (
      write__7
    )
      ob x.field4;
    (match x.field5 with None -> () | Some x ->
      if !is_first then
        is_first := false
      else
        Bi_outbuf.add_char ob ',';
      Bi_outbuf.add_string ob "\"field5\":";
      (
        Yojson.Safe.write_bool
      )
        ob x;
    );
    (match x.field6 with None -> () | Some x ->
      if !is_first then
        is_first := false
      else
        Bi_outbuf.add_char ob ',';
      Bi_outbuf.add_string ob "\"field6\":";
      (
        Yojson.Safe.write_string
      )
        ob x;
    );
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"field7\":";
    (
      write_test_variant
    )
      ob x.field7;
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"field8\":";
    (
      write__9
    )
      ob x.field8;
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"field9\":";
    (
      fun ob x ->
        Bi_outbuf.add_char ob '[';
        (let x, _, _, _, _, _ = x in
        (
          Yojson.Safe.write_int
        ) ob x
        );
        Bi_outbuf.add_char ob ',';
        (let _, x, _, _, _, _ = x in
        (
          Yojson.Safe.write_int
        ) ob x
        );
        Bi_outbuf.add_char ob ',';
        (let _, _, x, _, _, _ = x in
        (
          Atdgen_runtime.Oj_run.write_int8
        ) ob x
        );
        Bi_outbuf.add_char ob ',';
        (let _, _, _, x, _, _ = x in
        (
          Yojson.Safe.write_int
        ) ob x
        );
        Bi_outbuf.add_char ob ',';
        (let _, _, _, _, x, _ = x in
        (
          Atdgen_runtime.Oj_run.write_int32
        ) ob x
        );
        Bi_outbuf.add_char ob ',';
        (let _, _, _, _, _, x = x in
        (
          Atdgen_runtime.Oj_run.write_int64
        ) ob x
        );
        Bi_outbuf.add_char ob ']';
    )
      ob x.field9;
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"field10\":";
    (
      Yojson.Safe.write_bool
    )
      ob x.field10;
    if x.field11 <> false then (
      if !is_first then
        is_first := false
      else
        Bi_outbuf.add_char ob ',';
      Bi_outbuf.add_string ob "\"field11\":";
      (
        Yojson.Safe.write_bool
      )
        ob x.field11;
    );
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"field12\":";
    (
      write__10
    )
      ob x.field12;
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"field13\":";
    (
      write__11
    )
      ob x.field13;
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"field14\":";
    (
      write_date
    )
      ob x.field14;
    Bi_outbuf.add_char ob '}';
)
let string_of_mixed_record ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_mixed_record ob x;
  Bi_outbuf.contents ob
let read_mixed_record = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    Yojson.Safe.read_lcurl p lb;
    let field_field0 = ref (None) in
    let field_field1 = ref (None) in
    let field_field2 = ref (None) in
    let field_field3 = ref (None) in
    let field_field4 = ref (None) in
    let field_field5 = ref (None) in
    let field_field6 = ref (None) in
    let field_field7 = ref (None) in
    let field_field8 = ref (None) in
    let field_field9 = ref (None) in
    let field_field10 = ref (None) in
    let field_field11 = ref (false) in
    let field_field12 = ref (None) in
    let field_field13 = ref (None) in
    let field_field14 = ref (None) in
    try
      Yojson.Safe.read_space p lb;
      Yojson.Safe.read_object_end lb;
      Yojson.Safe.read_space p lb;
      let f =
        fun s pos len ->
          if pos < 0 || len < 0 || pos + len > String.length s then
            invalid_arg "out-of-bounds substring position or length";
          match len with
            | 6 -> (
                if String.unsafe_get s pos = 'f' && String.unsafe_get s (pos+1) = 'i' && String.unsafe_get s (pos+2) = 'e' && String.unsafe_get s (pos+3) = 'l' && String.unsafe_get s (pos+4) = 'd' then (
                  match String.unsafe_get s (pos+5) with
                    | '0' -> (
                        0
                      )
                    | '1' -> (
                        1
                      )
                    | '2' -> (
                        2
                      )
                    | '3' -> (
                        3
                      )
                    | '4' -> (
                        4
                      )
                    | '5' -> (
                        5
                      )
                    | '6' -> (
                        6
                      )
                    | '7' -> (
                        7
                      )
                    | '8' -> (
                        8
                      )
                    | '9' -> (
                        9
                      )
                    | _ -> (
                        -1
                      )
                )
                else (
                  -1
                )
              )
            | 7 -> (
                if String.unsafe_get s pos = 'f' && String.unsafe_get s (pos+1) = 'i' && String.unsafe_get s (pos+2) = 'e' && String.unsafe_get s (pos+3) = 'l' && String.unsafe_get s (pos+4) = 'd' && String.unsafe_get s (pos+5) = '1' then (
                  match String.unsafe_get s (pos+6) with
                    | '0' -> (
                        10
                      )
                    | '1' -> (
                        11
                      )
                    | '2' -> (
                        12
                      )
                    | '3' -> (
                        13
                      )
                    | '4' -> (
                        14
                      )
                    | _ -> (
                        -1
                      )
                )
                else (
                  -1
                )
              )
            | _ -> (
                -1
              )
      in
      let i = Yojson.Safe.map_ident p f lb in
      Atdgen_runtime.Oj_run.read_until_field_value p lb;
      (
        match i with
          | 0 ->
            if not (Yojson.Safe.read_null_if_possible p lb) then (
              field_field0 := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_int
                  ) p lb
                )
              );
            )
          | 1 ->
            if not (Yojson.Safe.read_null_if_possible p lb) then (
              field_field1 := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_number
                  ) p lb
                )
              );
            )
          | 2 ->
            field_field2 := (
              Some (
                (
                  read__6
                ) p lb
              )
            );
          | 3 ->
            field_field3 := (
              Some (
                (
                  Atdgen_runtime.Oj_run.read_int64
                ) p lb
              )
            );
          | 4 ->
            field_field4 := (
              Some (
                (
                  read__7
                ) p lb
              )
            );
          | 5 ->
            if not (Yojson.Safe.read_null_if_possible p lb) then (
              field_field5 := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_bool
                  ) p lb
                )
              );
            )
          | 6 ->
            if not (Yojson.Safe.read_null_if_possible p lb) then (
              field_field6 := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_string
                  ) p lb
                )
              );
            )
          | 7 ->
            field_field7 := (
              Some (
                (
                  read_test_variant
                ) p lb
              )
            );
          | 8 ->
            field_field8 := (
              Some (
                (
                  read__9
                ) p lb
              )
            );
          | 9 ->
            field_field9 := (
              Some (
                (
                  fun p lb ->
                    Yojson.Safe.read_space p lb;
                    let std_tuple = Yojson.Safe.start_any_tuple p lb in
                    let len = ref 0 in
                    let end_of_tuple = ref false in
                    (try
                      let x0 =
                        let x =
                          (
                            Atdgen_runtime.Oj_run.read_int
                          ) p lb
                        in
                        incr len;
                        Yojson.Safe.read_space p lb;
                        Yojson.Safe.read_tuple_sep2 p std_tuple lb;
                        x
                      in
                      let x1 =
                        let x =
                          (
                            Atdgen_runtime.Oj_run.read_int
                          ) p lb
                        in
                        incr len;
                        Yojson.Safe.read_space p lb;
                        Yojson.Safe.read_tuple_sep2 p std_tuple lb;
                        x
                      in
                      let x2 =
                        let x =
                          (
                            Atdgen_runtime.Oj_run.read_int8
                          ) p lb
                        in
                        incr len;
                        Yojson.Safe.read_space p lb;
                        Yojson.Safe.read_tuple_sep2 p std_tuple lb;
                        x
                      in
                      let x3 =
                        let x =
                          (
                            Atdgen_runtime.Oj_run.read_int
                          ) p lb
                        in
                        incr len;
                        Yojson.Safe.read_space p lb;
                        Yojson.Safe.read_tuple_sep2 p std_tuple lb;
                        x
                      in
                      let x4 =
                        let x =
                          (
                            Atdgen_runtime.Oj_run.read_int32
                          ) p lb
                        in
                        incr len;
                        Yojson.Safe.read_space p lb;
                        Yojson.Safe.read_tuple_sep2 p std_tuple lb;
                        x
                      in
                      let x5 =
                        let x =
                          (
                            Atdgen_runtime.Oj_run.read_int64
                          ) p lb
                        in
                        incr len;
                        (try
                          Yojson.Safe.read_space p lb;
                          Yojson.Safe.read_tuple_sep2 p std_tuple lb;
                        with Yojson.End_of_tuple -> end_of_tuple := true);
                        x
                      in
                      if not !end_of_tuple then (
                        try
                          while true do
                            Yojson.Safe.skip_json p lb;
                            Yojson.Safe.read_space p lb;
                            Yojson.Safe.read_tuple_sep2 p std_tuple lb;
                          done
                        with Yojson.End_of_tuple -> ()
                      );
                      (x0, x1, x2, x3, x4, x5)
                    with Yojson.End_of_tuple ->
                      Atdgen_runtime.Oj_run.missing_tuple_fields p !len [ 0; 1; 2; 3; 4; 5 ]);
                ) p lb
              )
            );
          | 10 ->
            field_field10 := (
              Some (
                (
                  Atdgen_runtime.Oj_run.read_bool
                ) p lb
              )
            );
          | 11 ->
            if not (Yojson.Safe.read_null_if_possible p lb) then (
              field_field11 := (
                (
                  Atdgen_runtime.Oj_run.read_bool
                ) p lb
              );
            )
          | 12 ->
            field_field12 := (
              Some (
                (
                  read__10
                ) p lb
              )
            );
          | 13 ->
            field_field13 := (
              Some (
                (
                  read__11
                ) p lb
              )
            );
          | 14 ->
            field_field14 := (
              Some (
                (
                  read_date
                ) p lb
              )
            );
          | _ -> (
              Yojson.Safe.skip_json p lb
            )
      );
      while true do
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_object_sep p lb;
        Yojson.Safe.read_space p lb;
        let f =
          fun s pos len ->
            if pos < 0 || len < 0 || pos + len > String.length s then
              invalid_arg "out-of-bounds substring position or length";
            match len with
              | 6 -> (
                  if String.unsafe_get s pos = 'f' && String.unsafe_get s (pos+1) = 'i' && String.unsafe_get s (pos+2) = 'e' && String.unsafe_get s (pos+3) = 'l' && String.unsafe_get s (pos+4) = 'd' then (
                    match String.unsafe_get s (pos+5) with
                      | '0' -> (
                          0
                        )
                      | '1' -> (
                          1
                        )
                      | '2' -> (
                          2
                        )
                      | '3' -> (
                          3
                        )
                      | '4' -> (
                          4
                        )
                      | '5' -> (
                          5
                        )
                      | '6' -> (
                          6
                        )
                      | '7' -> (
                          7
                        )
                      | '8' -> (
                          8
                        )
                      | '9' -> (
                          9
                        )
                      | _ -> (
                          -1
                        )
                  )
                  else (
                    -1
                  )
                )
              | 7 -> (
                  if String.unsafe_get s pos = 'f' && String.unsafe_get s (pos+1) = 'i' && String.unsafe_get s (pos+2) = 'e' && String.unsafe_get s (pos+3) = 'l' && String.unsafe_get s (pos+4) = 'd' && String.unsafe_get s (pos+5) = '1' then (
                    match String.unsafe_get s (pos+6) with
                      | '0' -> (
                          10
                        )
                      | '1' -> (
                          11
                        )
                      | '2' -> (
                          12
                        )
                      | '3' -> (
                          13
                        )
                      | '4' -> (
                          14
                        )
                      | _ -> (
                          -1
                        )
                  )
                  else (
                    -1
                  )
                )
              | _ -> (
                  -1
                )
        in
        let i = Yojson.Safe.map_ident p f lb in
        Atdgen_runtime.Oj_run.read_until_field_value p lb;
        (
          match i with
            | 0 ->
              if not (Yojson.Safe.read_null_if_possible p lb) then (
                field_field0 := (
                  Some (
                    (
                      Atdgen_runtime.Oj_run.read_int
                    ) p lb
                  )
                );
              )
            | 1 ->
              if not (Yojson.Safe.read_null_if_possible p lb) then (
                field_field1 := (
                  Some (
                    (
                      Atdgen_runtime.Oj_run.read_number
                    ) p lb
                  )
                );
              )
            | 2 ->
              field_field2 := (
                Some (
                  (
                    read__6
                  ) p lb
                )
              );
            | 3 ->
              field_field3 := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_int64
                  ) p lb
                )
              );
            | 4 ->
              field_field4 := (
                Some (
                  (
                    read__7
                  ) p lb
                )
              );
            | 5 ->
              if not (Yojson.Safe.read_null_if_possible p lb) then (
                field_field5 := (
                  Some (
                    (
                      Atdgen_runtime.Oj_run.read_bool
                    ) p lb
                  )
                );
              )
            | 6 ->
              if not (Yojson.Safe.read_null_if_possible p lb) then (
                field_field6 := (
                  Some (
                    (
                      Atdgen_runtime.Oj_run.read_string
                    ) p lb
                  )
                );
              )
            | 7 ->
              field_field7 := (
                Some (
                  (
                    read_test_variant
                  ) p lb
                )
              );
            | 8 ->
              field_field8 := (
                Some (
                  (
                    read__9
                  ) p lb
                )
              );
            | 9 ->
              field_field9 := (
                Some (
                  (
                    fun p lb ->
                      Yojson.Safe.read_space p lb;
                      let std_tuple = Yojson.Safe.start_any_tuple p lb in
                      let len = ref 0 in
                      let end_of_tuple = ref false in
                      (try
                        let x0 =
                          let x =
                            (
                              Atdgen_runtime.Oj_run.read_int
                            ) p lb
                          in
                          incr len;
                          Yojson.Safe.read_space p lb;
                          Yojson.Safe.read_tuple_sep2 p std_tuple lb;
                          x
                        in
                        let x1 =
                          let x =
                            (
                              Atdgen_runtime.Oj_run.read_int
                            ) p lb
                          in
                          incr len;
                          Yojson.Safe.read_space p lb;
                          Yojson.Safe.read_tuple_sep2 p std_tuple lb;
                          x
                        in
                        let x2 =
                          let x =
                            (
                              Atdgen_runtime.Oj_run.read_int8
                            ) p lb
                          in
                          incr len;
                          Yojson.Safe.read_space p lb;
                          Yojson.Safe.read_tuple_sep2 p std_tuple lb;
                          x
                        in
                        let x3 =
                          let x =
                            (
                              Atdgen_runtime.Oj_run.read_int
                            ) p lb
                          in
                          incr len;
                          Yojson.Safe.read_space p lb;
                          Yojson.Safe.read_tuple_sep2 p std_tuple lb;
                          x
                        in
                        let x4 =
                          let x =
                            (
                              Atdgen_runtime.Oj_run.read_int32
                            ) p lb
                          in
                          incr len;
                          Yojson.Safe.read_space p lb;
                          Yojson.Safe.read_tuple_sep2 p std_tuple lb;
                          x
                        in
                        let x5 =
                          let x =
                            (
                              Atdgen_runtime.Oj_run.read_int64
                            ) p lb
                          in
                          incr len;
                          (try
                            Yojson.Safe.read_space p lb;
                            Yojson.Safe.read_tuple_sep2 p std_tuple lb;
                          with Yojson.End_of_tuple -> end_of_tuple := true);
                          x
                        in
                        if not !end_of_tuple then (
                          try
                            while true do
                              Yojson.Safe.skip_json p lb;
                              Yojson.Safe.read_space p lb;
                              Yojson.Safe.read_tuple_sep2 p std_tuple lb;
                            done
                          with Yojson.End_of_tuple -> ()
                        );
                        (x0, x1, x2, x3, x4, x5)
                      with Yojson.End_of_tuple ->
                        Atdgen_runtime.Oj_run.missing_tuple_fields p !len [ 0; 1; 2; 3; 4; 5 ]);
                  ) p lb
                )
              );
            | 10 ->
              field_field10 := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_bool
                  ) p lb
                )
              );
            | 11 ->
              if not (Yojson.Safe.read_null_if_possible p lb) then (
                field_field11 := (
                  (
                    Atdgen_runtime.Oj_run.read_bool
                  ) p lb
                );
              )
            | 12 ->
              field_field12 := (
                Some (
                  (
                    read__10
                  ) p lb
                )
              );
            | 13 ->
              field_field13 := (
                Some (
                  (
                    read__11
                  ) p lb
                )
              );
            | 14 ->
              field_field14 := (
                Some (
                  (
                    read_date
                  ) p lb
                )
              );
            | _ -> (
                Yojson.Safe.skip_json p lb
              )
        );
      done;
      assert false;
    with Yojson.End_of_object -> (
        (
          {
            field0 = !field_field0;
            field1 = !field_field1;
            field2 = (match !field_field2 with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "field2");
            field3 = (match !field_field3 with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "field3");
            field4 = (match !field_field4 with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "field4");
            field5 = !field_field5;
            field6 = !field_field6;
            field7 = (match !field_field7 with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "field7");
            field8 = (match !field_field8 with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "field8");
            field9 = (match !field_field9 with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "field9");
            field10 = (match !field_field10 with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "field10");
            field11 = !field_field11;
            field12 = (match !field_field12 with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "field12");
            field13 = (match !field_field13 with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "field13");
            field14 = (match !field_field14 with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "field14");
          }
         : mixed_record)
      )
)
let mixed_record_of_string s =
  read_mixed_record (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__13 = (
  Atdgen_runtime.Oj_run.write_array (
    write_mixed_record
  )
)
let string_of__13 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__13 ob x;
  Bi_outbuf.contents ob
let read__13 = (
  Atdgen_runtime.Oj_run.read_array (
    read_mixed_record
  )
)
let _13_of_string s =
  read__13 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__12 = (
  Atdgen_runtime.Oj_run.write_array (
    write_mixed_record
  )
)
let string_of__12 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__12 ob x;
  Bi_outbuf.contents ob
let read__12 = (
  Atdgen_runtime.Oj_run.read_array (
    read_mixed_record
  )
)
let _12_of_string s =
  read__12 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__14 = (
  Atdgen_runtime.Oj_run.write_list (
    fun ob x ->
      Bi_outbuf.add_char ob '[';
      (let x, _ = x in
      (
        write__12
      ) ob x
      );
      Bi_outbuf.add_char ob ',';
      (let _, x = x in
      (
        write__13
      ) ob x
      );
      Bi_outbuf.add_char ob ']';
  )
)
let string_of__14 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__14 ob x;
  Bi_outbuf.contents ob
let read__14 = (
  Atdgen_runtime.Oj_run.read_list (
    fun p lb ->
      Yojson.Safe.read_space p lb;
      let std_tuple = Yojson.Safe.start_any_tuple p lb in
      let len = ref 0 in
      let end_of_tuple = ref false in
      (try
        let x0 =
          let x =
            (
              read__12
            ) p lb
          in
          incr len;
          Yojson.Safe.read_space p lb;
          Yojson.Safe.read_tuple_sep2 p std_tuple lb;
          x
        in
        let x1 =
          let x =
            (
              read__13
            ) p lb
          in
          incr len;
          (try
            Yojson.Safe.read_space p lb;
            Yojson.Safe.read_tuple_sep2 p std_tuple lb;
          with Yojson.End_of_tuple -> end_of_tuple := true);
          x
        in
        if not !end_of_tuple then (
          try
            while true do
              Yojson.Safe.skip_json p lb;
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_tuple_sep2 p std_tuple lb;
            done
          with Yojson.End_of_tuple -> ()
        );
        (x0, x1)
      with Yojson.End_of_tuple ->
        Atdgen_runtime.Oj_run.missing_tuple_fields p !len [ 0; 1 ]);
  )
)
let _14_of_string s =
  read__14 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_mixed = (
  write__14
)
let string_of_mixed ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_mixed ob x;
  Bi_outbuf.contents ob
let read_mixed = (
  read__14
)
let mixed_of_string s =
  read_mixed (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__15 = (
  Atdgen_runtime.Oj_run.write_list (
    write_mixed_record
  )
)
let string_of__15 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__15 ob x;
  Bi_outbuf.contents ob
let read__15 = (
  Atdgen_runtime.Oj_run.read_list (
    read_mixed_record
  )
)
let _15_of_string s =
  read__15 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_test : _ -> test -> _ = (
  fun ob (x : test) ->
    Bi_outbuf.add_char ob '{';
    let is_first = ref true in
    (match x.x0 with None -> () | Some x ->
      if !is_first then
        is_first := false
      else
        Bi_outbuf.add_char ob ',';
      Bi_outbuf.add_string ob "\"x0\":";
      (
        Yojson.Safe.write_int
      )
        ob x;
    );
    (match x.x1 with None -> () | Some x ->
      if !is_first then
        is_first := false
      else
        Bi_outbuf.add_char ob ',';
      Bi_outbuf.add_string ob "\"x1\":";
      (
        Yojson.Safe.write_std_float
      )
        ob x;
    );
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"x2\":";
    (
      write_mixed
    )
      ob x.x2;
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"x3\":";
    (
      write__15
    )
      ob x.x3;
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"x4\":";
    (
      Atdgen_runtime.Oj_run.write_int64
    )
      ob x.x4;
    Bi_outbuf.add_char ob '}';
)
let string_of_test ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_test ob x;
  Bi_outbuf.contents ob
let read_test = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    Yojson.Safe.read_lcurl p lb;
    let field_x0 = ref (None) in
    let field_x1 = ref (None) in
    let field_x2 = ref (None) in
    let field_x3 = ref (None) in
    let field_x4 = ref (None) in
    try
      Yojson.Safe.read_space p lb;
      Yojson.Safe.read_object_end lb;
      Yojson.Safe.read_space p lb;
      let f =
        fun s pos len ->
          if pos < 0 || len < 0 || pos + len > String.length s then
            invalid_arg "out-of-bounds substring position or length";
          if len = 2 && String.unsafe_get s pos = 'x' then (
            match String.unsafe_get s (pos+1) with
              | '0' -> (
                  0
                )
              | '1' -> (
                  1
                )
              | '2' -> (
                  2
                )
              | '3' -> (
                  3
                )
              | '4' -> (
                  4
                )
              | _ -> (
                  -1
                )
          )
          else (
            -1
          )
      in
      let i = Yojson.Safe.map_ident p f lb in
      Atdgen_runtime.Oj_run.read_until_field_value p lb;
      (
        match i with
          | 0 ->
            if not (Yojson.Safe.read_null_if_possible p lb) then (
              field_x0 := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_int
                  ) p lb
                )
              );
            )
          | 1 ->
            if not (Yojson.Safe.read_null_if_possible p lb) then (
              field_x1 := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_number
                  ) p lb
                )
              );
            )
          | 2 ->
            field_x2 := (
              Some (
                (
                  read_mixed
                ) p lb
              )
            );
          | 3 ->
            field_x3 := (
              Some (
                (
                  read__15
                ) p lb
              )
            );
          | 4 ->
            field_x4 := (
              Some (
                (
                  Atdgen_runtime.Oj_run.read_int64
                ) p lb
              )
            );
          | _ -> (
              Yojson.Safe.skip_json p lb
            )
      );
      while true do
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_object_sep p lb;
        Yojson.Safe.read_space p lb;
        let f =
          fun s pos len ->
            if pos < 0 || len < 0 || pos + len > String.length s then
              invalid_arg "out-of-bounds substring position or length";
            if len = 2 && String.unsafe_get s pos = 'x' then (
              match String.unsafe_get s (pos+1) with
                | '0' -> (
                    0
                  )
                | '1' -> (
                    1
                  )
                | '2' -> (
                    2
                  )
                | '3' -> (
                    3
                  )
                | '4' -> (
                    4
                  )
                | _ -> (
                    -1
                  )
            )
            else (
              -1
            )
        in
        let i = Yojson.Safe.map_ident p f lb in
        Atdgen_runtime.Oj_run.read_until_field_value p lb;
        (
          match i with
            | 0 ->
              if not (Yojson.Safe.read_null_if_possible p lb) then (
                field_x0 := (
                  Some (
                    (
                      Atdgen_runtime.Oj_run.read_int
                    ) p lb
                  )
                );
              )
            | 1 ->
              if not (Yojson.Safe.read_null_if_possible p lb) then (
                field_x1 := (
                  Some (
                    (
                      Atdgen_runtime.Oj_run.read_number
                    ) p lb
                  )
                );
              )
            | 2 ->
              field_x2 := (
                Some (
                  (
                    read_mixed
                  ) p lb
                )
              );
            | 3 ->
              field_x3 := (
                Some (
                  (
                    read__15
                  ) p lb
                )
              );
            | 4 ->
              field_x4 := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_int64
                  ) p lb
                )
              );
            | _ -> (
                Yojson.Safe.skip_json p lb
              )
        );
      done;
      assert false;
    with Yojson.End_of_object -> (
        (
          {
            x0 = !field_x0;
            x1 = !field_x1;
            x2 = (match !field_x2 with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "x2");
            x3 = (match !field_x3 with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "x3");
            x4 = (match !field_x4 with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "x4");
          }
         : test)
      )
)
let test_of_string s =
  read_test (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_tup = (
  fun ob x ->
    Bi_outbuf.add_char ob '[';
    (let x, _ = x in
    (
      Yojson.Safe.write_int
    ) ob x
    );
    Bi_outbuf.add_char ob ',';
    (let _, x = x in
    (
      write_test
    ) ob x
    );
    Bi_outbuf.add_char ob ']';
)
let string_of_tup ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_tup ob x;
  Bi_outbuf.contents ob
let read_tup = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    let std_tuple = Yojson.Safe.start_any_tuple p lb in
    let len = ref 0 in
    let end_of_tuple = ref false in
    (try
      let x0 =
        let x =
          (
            Atdgen_runtime.Oj_run.read_int
          ) p lb
        in
        incr len;
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_tuple_sep2 p std_tuple lb;
        x
      in
      let x1 =
        let x =
          (
            read_test
          ) p lb
        in
        incr len;
        (try
          Yojson.Safe.read_space p lb;
          Yojson.Safe.read_tuple_sep2 p std_tuple lb;
        with Yojson.End_of_tuple -> end_of_tuple := true);
        x
      in
      if not !end_of_tuple then (
        try
          while true do
            Yojson.Safe.skip_json p lb;
            Yojson.Safe.read_space p lb;
            Yojson.Safe.read_tuple_sep2 p std_tuple lb;
          done
        with Yojson.End_of_tuple -> ()
      );
      (x0, x1)
    with Yojson.End_of_tuple ->
      Atdgen_runtime.Oj_run.missing_tuple_fields p !len [ 0; 1 ]);
)
let tup_of_string s =
  read_tup (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_star_rating = (
  Yojson.Safe.write_int
)
let string_of_star_rating ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_star_rating ob x;
  Bi_outbuf.contents ob
let read_star_rating = (
  Atdgen_runtime.Oj_run.read_int
)
let star_rating_of_string s =
  read_star_rating (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__30 : _ -> _ generic -> _ = (
  fun ob (x : _ generic) ->
    Bi_outbuf.add_char ob '{';
    let is_first = ref true in
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"x294623\":";
    (
      Yojson.Safe.write_int
    )
      ob x.x294623;
    Bi_outbuf.add_char ob '}';
)
let string_of__30 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__30 ob x;
  Bi_outbuf.contents ob
let read__30 = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    Yojson.Safe.read_lcurl p lb;
    let field_x294623 = ref (None) in
    try
      Yojson.Safe.read_space p lb;
      Yojson.Safe.read_object_end lb;
      Yojson.Safe.read_space p lb;
      let f =
        fun s pos len ->
          if pos < 0 || len < 0 || pos + len > String.length s then
            invalid_arg "out-of-bounds substring position or length";
          if len = 7 && String.unsafe_get s pos = 'x' && String.unsafe_get s (pos+1) = '2' && String.unsafe_get s (pos+2) = '9' && String.unsafe_get s (pos+3) = '4' && String.unsafe_get s (pos+4) = '6' && String.unsafe_get s (pos+5) = '2' && String.unsafe_get s (pos+6) = '3' then (
            0
          )
          else (
            -1
          )
      in
      let i = Yojson.Safe.map_ident p f lb in
      Atdgen_runtime.Oj_run.read_until_field_value p lb;
      (
        match i with
          | 0 ->
            field_x294623 := (
              Some (
                (
                  Atdgen_runtime.Oj_run.read_int
                ) p lb
              )
            );
          | _ -> (
              Yojson.Safe.skip_json p lb
            )
      );
      while true do
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_object_sep p lb;
        Yojson.Safe.read_space p lb;
        let f =
          fun s pos len ->
            if pos < 0 || len < 0 || pos + len > String.length s then
              invalid_arg "out-of-bounds substring position or length";
            if len = 7 && String.unsafe_get s pos = 'x' && String.unsafe_get s (pos+1) = '2' && String.unsafe_get s (pos+2) = '9' && String.unsafe_get s (pos+3) = '4' && String.unsafe_get s (pos+4) = '6' && String.unsafe_get s (pos+5) = '2' && String.unsafe_get s (pos+6) = '3' then (
              0
            )
            else (
              -1
            )
        in
        let i = Yojson.Safe.map_ident p f lb in
        Atdgen_runtime.Oj_run.read_until_field_value p lb;
        (
          match i with
            | 0 ->
              field_x294623 := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_int
                  ) p lb
                )
              );
            | _ -> (
                Yojson.Safe.skip_json p lb
              )
        );
      done;
      assert false;
    with Yojson.End_of_object -> (
        (
          {
            x294623 = (match !field_x294623 with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "x294623");
          }
         : _ generic)
      )
)
let _30_of_string s =
  read__30 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_specialized = (
  write__30
)
let string_of_specialized ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_specialized ob x;
  Bi_outbuf.contents ob
let read_specialized = (
  read__30
)
let specialized_of_string s =
  read_specialized (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_some_record : _ -> some_record -> _ = (
  fun ob (x : some_record) ->
    Bi_outbuf.add_char ob '{';
    let is_first = ref true in
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"some_field\":";
    (
      Yojson.Safe.write_int
    )
      ob x.some_field;
    Bi_outbuf.add_char ob '}';
)
let string_of_some_record ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_some_record ob x;
  Bi_outbuf.contents ob
let read_some_record = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    Yojson.Safe.read_lcurl p lb;
    let field_some_field = ref (None) in
    try
      Yojson.Safe.read_space p lb;
      Yojson.Safe.read_object_end lb;
      Yojson.Safe.read_space p lb;
      let f =
        fun s pos len ->
          if pos < 0 || len < 0 || pos + len > String.length s then
            invalid_arg "out-of-bounds substring position or length";
          if len = 10 && String.unsafe_get s pos = 's' && String.unsafe_get s (pos+1) = 'o' && String.unsafe_get s (pos+2) = 'm' && String.unsafe_get s (pos+3) = 'e' && String.unsafe_get s (pos+4) = '_' && String.unsafe_get s (pos+5) = 'f' && String.unsafe_get s (pos+6) = 'i' && String.unsafe_get s (pos+7) = 'e' && String.unsafe_get s (pos+8) = 'l' && String.unsafe_get s (pos+9) = 'd' then (
            0
          )
          else (
            -1
          )
      in
      let i = Yojson.Safe.map_ident p f lb in
      Atdgen_runtime.Oj_run.read_until_field_value p lb;
      (
        match i with
          | 0 ->
            field_some_field := (
              Some (
                (
                  Atdgen_runtime.Oj_run.read_int
                ) p lb
              )
            );
          | _ -> (
              Yojson.Safe.skip_json p lb
            )
      );
      while true do
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_object_sep p lb;
        Yojson.Safe.read_space p lb;
        let f =
          fun s pos len ->
            if pos < 0 || len < 0 || pos + len > String.length s then
              invalid_arg "out-of-bounds substring position or length";
            if len = 10 && String.unsafe_get s pos = 's' && String.unsafe_get s (pos+1) = 'o' && String.unsafe_get s (pos+2) = 'm' && String.unsafe_get s (pos+3) = 'e' && String.unsafe_get s (pos+4) = '_' && String.unsafe_get s (pos+5) = 'f' && String.unsafe_get s (pos+6) = 'i' && String.unsafe_get s (pos+7) = 'e' && String.unsafe_get s (pos+8) = 'l' && String.unsafe_get s (pos+9) = 'd' then (
              0
            )
            else (
              -1
            )
        in
        let i = Yojson.Safe.map_ident p f lb in
        Atdgen_runtime.Oj_run.read_until_field_value p lb;
        (
          match i with
            | 0 ->
              field_some_field := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_int
                  ) p lb
                )
              );
            | _ -> (
                Yojson.Safe.skip_json p lb
              )
        );
      done;
      assert false;
    with Yojson.End_of_object -> (
        (
          {
            some_field = (match !field_some_field with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "some_field");
          }
         : some_record)
      )
)
let some_record_of_string s =
  read_some_record (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_precision : _ -> precision -> _ = (
  fun ob (x : precision) ->
    Bi_outbuf.add_char ob '{';
    let is_first = ref true in
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"sqrt2_5\":";
    (
      Yojson.Safe.write_std_float_prec 5
    )
      ob x.sqrt2_5;
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"small_2\":";
    (
      Yojson.Safe.write_std_float_prec 2
    )
      ob x.small_2;
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"large_2\":";
    (
      Yojson.Safe.write_std_float_prec 2
    )
      ob x.large_2;
    Bi_outbuf.add_char ob '}';
)
let string_of_precision ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_precision ob x;
  Bi_outbuf.contents ob
let read_precision = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    Yojson.Safe.read_lcurl p lb;
    let field_sqrt2_5 = ref (None) in
    let field_small_2 = ref (None) in
    let field_large_2 = ref (None) in
    try
      Yojson.Safe.read_space p lb;
      Yojson.Safe.read_object_end lb;
      Yojson.Safe.read_space p lb;
      let f =
        fun s pos len ->
          if pos < 0 || len < 0 || pos + len > String.length s then
            invalid_arg "out-of-bounds substring position or length";
          if len = 7 then (
            match String.unsafe_get s pos with
              | 'l' -> (
                  if String.unsafe_get s (pos+1) = 'a' && String.unsafe_get s (pos+2) = 'r' && String.unsafe_get s (pos+3) = 'g' && String.unsafe_get s (pos+4) = 'e' && String.unsafe_get s (pos+5) = '_' && String.unsafe_get s (pos+6) = '2' then (
                    2
                  )
                  else (
                    -1
                  )
                )
              | 's' -> (
                  match String.unsafe_get s (pos+1) with
                    | 'm' -> (
                        if String.unsafe_get s (pos+2) = 'a' && String.unsafe_get s (pos+3) = 'l' && String.unsafe_get s (pos+4) = 'l' && String.unsafe_get s (pos+5) = '_' && String.unsafe_get s (pos+6) = '2' then (
                          1
                        )
                        else (
                          -1
                        )
                      )
                    | 'q' -> (
                        if String.unsafe_get s (pos+2) = 'r' && String.unsafe_get s (pos+3) = 't' && String.unsafe_get s (pos+4) = '2' && String.unsafe_get s (pos+5) = '_' && String.unsafe_get s (pos+6) = '5' then (
                          0
                        )
                        else (
                          -1
                        )
                      )
                    | _ -> (
                        -1
                      )
                )
              | _ -> (
                  -1
                )
          )
          else (
            -1
          )
      in
      let i = Yojson.Safe.map_ident p f lb in
      Atdgen_runtime.Oj_run.read_until_field_value p lb;
      (
        match i with
          | 0 ->
            field_sqrt2_5 := (
              Some (
                (
                  Atdgen_runtime.Oj_run.read_number
                ) p lb
              )
            );
          | 1 ->
            field_small_2 := (
              Some (
                (
                  Atdgen_runtime.Oj_run.read_number
                ) p lb
              )
            );
          | 2 ->
            field_large_2 := (
              Some (
                (
                  Atdgen_runtime.Oj_run.read_number
                ) p lb
              )
            );
          | _ -> (
              Yojson.Safe.skip_json p lb
            )
      );
      while true do
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_object_sep p lb;
        Yojson.Safe.read_space p lb;
        let f =
          fun s pos len ->
            if pos < 0 || len < 0 || pos + len > String.length s then
              invalid_arg "out-of-bounds substring position or length";
            if len = 7 then (
              match String.unsafe_get s pos with
                | 'l' -> (
                    if String.unsafe_get s (pos+1) = 'a' && String.unsafe_get s (pos+2) = 'r' && String.unsafe_get s (pos+3) = 'g' && String.unsafe_get s (pos+4) = 'e' && String.unsafe_get s (pos+5) = '_' && String.unsafe_get s (pos+6) = '2' then (
                      2
                    )
                    else (
                      -1
                    )
                  )
                | 's' -> (
                    match String.unsafe_get s (pos+1) with
                      | 'm' -> (
                          if String.unsafe_get s (pos+2) = 'a' && String.unsafe_get s (pos+3) = 'l' && String.unsafe_get s (pos+4) = 'l' && String.unsafe_get s (pos+5) = '_' && String.unsafe_get s (pos+6) = '2' then (
                            1
                          )
                          else (
                            -1
                          )
                        )
                      | 'q' -> (
                          if String.unsafe_get s (pos+2) = 'r' && String.unsafe_get s (pos+3) = 't' && String.unsafe_get s (pos+4) = '2' && String.unsafe_get s (pos+5) = '_' && String.unsafe_get s (pos+6) = '5' then (
                            0
                          )
                          else (
                            -1
                          )
                        )
                      | _ -> (
                          -1
                        )
                  )
                | _ -> (
                    -1
                  )
            )
            else (
              -1
            )
        in
        let i = Yojson.Safe.map_ident p f lb in
        Atdgen_runtime.Oj_run.read_until_field_value p lb;
        (
          match i with
            | 0 ->
              field_sqrt2_5 := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_number
                  ) p lb
                )
              );
            | 1 ->
              field_small_2 := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_number
                  ) p lb
                )
              );
            | 2 ->
              field_large_2 := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_number
                  ) p lb
                )
              );
            | _ -> (
                Yojson.Safe.skip_json p lb
              )
        );
      done;
      assert false;
    with Yojson.End_of_object -> (
        (
          {
            sqrt2_5 = (match !field_sqrt2_5 with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "sqrt2_5");
            small_2 = (match !field_small_2 with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "small_2");
            large_2 = (match !field_large_2 with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "large_2");
          }
         : precision)
      )
)
let precision_of_string s =
  read_precision (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_p'' = (
  write__1
)
let string_of_p'' ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_p'' ob x;
  Bi_outbuf.contents ob
let read_p'' = (
  read__1
)
let p''_of_string s =
  read_p'' (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__18 = (
  Atdgen_runtime.Oj_run.write_std_option (
    Yojson.Safe.write_int
  )
)
let string_of__18 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__18 ob x;
  Bi_outbuf.contents ob
let read__18 = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    match Yojson.Safe.start_any_variant p lb with
      | `Edgy_bracket -> (
          match Yojson.Safe.read_ident p lb with
            | "None" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              (None : _ option)
            | "Some" ->
              Atdgen_runtime.Oj_run.read_until_field_value p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_int
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              (Some x : _ option)
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Double_quote -> (
          match Yojson.Safe.finish_string p lb with
            | "None" ->
              (None : _ option)
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Square_bracket -> (
          match Atdgen_runtime.Oj_run.read_string p lb with
            | "Some" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_comma p lb;
              Yojson.Safe.read_space p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_int
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_rbr p lb;
              (Some x : _ option)
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
)
let _18_of_string s =
  read__18 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_option_validation = (
  write__18
)
let string_of_option_validation ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_option_validation ob x;
  Bi_outbuf.contents ob
let read_option_validation = (
  read__18
)
let option_validation_of_string s =
  read_option_validation (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__28 = (
  write_some_record
)
let string_of__28 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__28 ob x;
  Bi_outbuf.contents ob
let read__28 = (
  read_some_record
)
let _28_of_string s =
  read__28 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_no_real_wrap = (
  write__28
)
let string_of_no_real_wrap ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_no_real_wrap ob x;
  Bi_outbuf.contents ob
let read_no_real_wrap = (
  read__28
)
let no_real_wrap_of_string s =
  read_no_real_wrap (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__26 = (
  fun ob x -> (
    let x = ( Test_lib.Natural.unwrap ) x in (
      Yojson.Safe.write_int
    ) ob x)
)
let string_of__26 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__26 ob x;
  Bi_outbuf.contents ob
let read__26 = (
  fun p lb ->
    let x = (
      Atdgen_runtime.Oj_run.read_int
    ) p lb in
    ( Test_lib.Natural.wrap ) x
)
let _26_of_string s =
  read__26 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_natural = (
  write__26
)
let string_of_natural ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_natural ob x;
  Bi_outbuf.contents ob
let read_natural = (
  read__26
)
let natural_of_string s =
  read_natural (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__24 = (
  fun ob x -> (
    let x = ( function `Id s -> s ) x in (
      Yojson.Safe.write_string
    ) ob x)
)
let string_of__24 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__24 ob x;
  Bi_outbuf.contents ob
let read__24 = (
  fun p lb ->
    let x = (
      Atdgen_runtime.Oj_run.read_string
    ) p lb in
    ( fun s -> `Id s ) x
)
let _24_of_string s =
  read__24 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_id = (
  write__24
)
let string_of_id ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_id ob x;
  Bi_outbuf.contents ob
let read_id = (
  read__24
)
let id_of_string s =
  read_id (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__25 = (
  Atdgen_runtime.Oj_run.write_assoc_list (
    write_id
  ) (
    Yojson.Safe.write_int
  )
)
let string_of__25 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__25 ob x;
  Bi_outbuf.contents ob
let read__25 = (
  Atdgen_runtime.Oj_run.read_assoc_list (
    read_id
  ) (
    Atdgen_runtime.Oj_run.read_int
  )
)
let _25_of_string s =
  read__25 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_json_map = (
  write__25
)
let string_of_json_map ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_json_map ob x;
  Bi_outbuf.contents ob
let read_json_map = (
  read__25
)
let json_map_of_string s =
  read_json_map (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_intopt = (
  write__4
)
let string_of_intopt ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_intopt ob x;
  Bi_outbuf.contents ob
let read_intopt = (
  read__4
)
let intopt_of_string s =
  read_intopt (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__21 = (
  Atdgen_runtime.Oj_run.write_assoc_list (
    Yojson.Safe.write_string
  ) (
    Yojson.Safe.write_int
  )
)
let string_of__21 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__21 ob x;
  Bi_outbuf.contents ob
let read__21 = (
  Atdgen_runtime.Oj_run.read_assoc_list (
    Atdgen_runtime.Oj_run.read_string
  ) (
    Atdgen_runtime.Oj_run.read_int
  )
)
let _21_of_string s =
  read__21 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_int_assoc_list = (
  write__21
)
let string_of_int_assoc_list ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_int_assoc_list ob x;
  Bi_outbuf.contents ob
let read_int_assoc_list = (
  read__21
)
let int_assoc_list_of_string s =
  read_int_assoc_list (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__22 = (
  Atdgen_runtime.Oj_run.write_assoc_array (
    Yojson.Safe.write_string
  ) (
    Yojson.Safe.write_int
  )
)
let string_of__22 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__22 ob x;
  Bi_outbuf.contents ob
let read__22 = (
  Atdgen_runtime.Oj_run.read_assoc_array (
    Atdgen_runtime.Oj_run.read_string
  ) (
    Atdgen_runtime.Oj_run.read_int
  )
)
let _22_of_string s =
  read__22 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_int_assoc_array = (
  write__22
)
let string_of_int_assoc_array ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_int_assoc_array ob x;
  Bi_outbuf.contents ob
let read_int_assoc_array = (
  read__22
)
let int_assoc_array_of_string s =
  read_int_assoc_array (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_int8 = (
  Yojson.Safe.write_int
)
let string_of_int8 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_int8 ob x;
  Bi_outbuf.contents ob
let read_int8 = (
  Atdgen_runtime.Oj_run.read_int
)
let int8_of_string s =
  read_int8 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_int64 = (
  Atdgen_runtime.Oj_run.write_int64
)
let string_of_int64 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_int64 ob x;
  Bi_outbuf.contents ob
let read_int64 = (
  Atdgen_runtime.Oj_run.read_int64
)
let int64_of_string s =
  read_int64 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_int32 = (
  Atdgen_runtime.Oj_run.write_int32
)
let string_of_int32 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_int32 ob x;
  Bi_outbuf.contents ob
let read_int32 = (
  Atdgen_runtime.Oj_run.read_int32
)
let int32_of_string s =
  read_int32 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_hello = (
  fun ob x ->
    match x with
      | `Hello x ->
        Bi_outbuf.add_string ob "[\"Hello\",";
        (
          Yojson.Safe.write_string
        ) ob x;
        Bi_outbuf.add_char ob ']'
      | `World -> Bi_outbuf.add_string ob "\"World\""
)
let string_of_hello ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_hello ob x;
  Bi_outbuf.contents ob
let read_hello = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    match Yojson.Safe.start_any_variant p lb with
      | `Edgy_bracket -> (
          match Yojson.Safe.read_ident p lb with
            | "Hello" ->
              Atdgen_runtime.Oj_run.read_until_field_value p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_string
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              `Hello x
            | "World" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_gt p lb;
              `World
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Double_quote -> (
          match Yojson.Safe.finish_string p lb with
            | "World" ->
              `World
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
      | `Square_bracket -> (
          match Atdgen_runtime.Oj_run.read_string p lb with
            | "Hello" ->
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_comma p lb;
              Yojson.Safe.read_space p lb;
              let x = (
                  Atdgen_runtime.Oj_run.read_string
                ) p lb
              in
              Yojson.Safe.read_space p lb;
              Yojson.Safe.read_rbr p lb;
              `Hello x
            | x ->
              Atdgen_runtime.Oj_run.invalid_variant_tag p x
        )
)
let hello_of_string s =
  read_hello (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_generic write__a : _ -> 'a generic -> _ = (
  fun ob (x : 'a generic) ->
    Bi_outbuf.add_char ob '{';
    let is_first = ref true in
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"x294623\":";
    (
      Yojson.Safe.write_int
    )
      ob x.x294623;
    Bi_outbuf.add_char ob '}';
)
let string_of_generic write__a ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_generic write__a ob x;
  Bi_outbuf.contents ob
let read_generic read__a = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    Yojson.Safe.read_lcurl p lb;
    let field_x294623 = ref (None) in
    try
      Yojson.Safe.read_space p lb;
      Yojson.Safe.read_object_end lb;
      Yojson.Safe.read_space p lb;
      let f =
        fun s pos len ->
          if pos < 0 || len < 0 || pos + len > String.length s then
            invalid_arg "out-of-bounds substring position or length";
          if len = 7 && String.unsafe_get s pos = 'x' && String.unsafe_get s (pos+1) = '2' && String.unsafe_get s (pos+2) = '9' && String.unsafe_get s (pos+3) = '4' && String.unsafe_get s (pos+4) = '6' && String.unsafe_get s (pos+5) = '2' && String.unsafe_get s (pos+6) = '3' then (
            0
          )
          else (
            -1
          )
      in
      let i = Yojson.Safe.map_ident p f lb in
      Atdgen_runtime.Oj_run.read_until_field_value p lb;
      (
        match i with
          | 0 ->
            field_x294623 := (
              Some (
                (
                  Atdgen_runtime.Oj_run.read_int
                ) p lb
              )
            );
          | _ -> (
              Yojson.Safe.skip_json p lb
            )
      );
      while true do
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_object_sep p lb;
        Yojson.Safe.read_space p lb;
        let f =
          fun s pos len ->
            if pos < 0 || len < 0 || pos + len > String.length s then
              invalid_arg "out-of-bounds substring position or length";
            if len = 7 && String.unsafe_get s pos = 'x' && String.unsafe_get s (pos+1) = '2' && String.unsafe_get s (pos+2) = '9' && String.unsafe_get s (pos+3) = '4' && String.unsafe_get s (pos+4) = '6' && String.unsafe_get s (pos+5) = '2' && String.unsafe_get s (pos+6) = '3' then (
              0
            )
            else (
              -1
            )
        in
        let i = Yojson.Safe.map_ident p f lb in
        Atdgen_runtime.Oj_run.read_until_field_value p lb;
        (
          match i with
            | 0 ->
              field_x294623 := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_int
                  ) p lb
                )
              );
            | _ -> (
                Yojson.Safe.skip_json p lb
              )
        );
      done;
      assert false;
    with Yojson.End_of_object -> (
        (
          {
            x294623 = (match !field_x294623 with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "x294623");
          }
         : 'a generic)
      )
)
let generic_of_string read__a s =
  read_generic read__a (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_floats : _ -> floats -> _ = (
  fun ob (x : floats) ->
    Bi_outbuf.add_char ob '{';
    let is_first = ref true in
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"f32\":";
    (
      Yojson.Safe.write_std_float
    )
      ob x.f32;
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"f64\":";
    (
      Yojson.Safe.write_std_float
    )
      ob x.f64;
    Bi_outbuf.add_char ob '}';
)
let string_of_floats ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_floats ob x;
  Bi_outbuf.contents ob
let read_floats = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    Yojson.Safe.read_lcurl p lb;
    let field_f32 = ref (None) in
    let field_f64 = ref (None) in
    try
      Yojson.Safe.read_space p lb;
      Yojson.Safe.read_object_end lb;
      Yojson.Safe.read_space p lb;
      let f =
        fun s pos len ->
          if pos < 0 || len < 0 || pos + len > String.length s then
            invalid_arg "out-of-bounds substring position or length";
          if len = 3 && String.unsafe_get s pos = 'f' then (
            match String.unsafe_get s (pos+1) with
              | '3' -> (
                  if String.unsafe_get s (pos+2) = '2' then (
                    0
                  )
                  else (
                    -1
                  )
                )
              | '6' -> (
                  if String.unsafe_get s (pos+2) = '4' then (
                    1
                  )
                  else (
                    -1
                  )
                )
              | _ -> (
                  -1
                )
          )
          else (
            -1
          )
      in
      let i = Yojson.Safe.map_ident p f lb in
      Atdgen_runtime.Oj_run.read_until_field_value p lb;
      (
        match i with
          | 0 ->
            field_f32 := (
              Some (
                (
                  Atdgen_runtime.Oj_run.read_number
                ) p lb
              )
            );
          | 1 ->
            field_f64 := (
              Some (
                (
                  Atdgen_runtime.Oj_run.read_number
                ) p lb
              )
            );
          | _ -> (
              Yojson.Safe.skip_json p lb
            )
      );
      while true do
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_object_sep p lb;
        Yojson.Safe.read_space p lb;
        let f =
          fun s pos len ->
            if pos < 0 || len < 0 || pos + len > String.length s then
              invalid_arg "out-of-bounds substring position or length";
            if len = 3 && String.unsafe_get s pos = 'f' then (
              match String.unsafe_get s (pos+1) with
                | '3' -> (
                    if String.unsafe_get s (pos+2) = '2' then (
                      0
                    )
                    else (
                      -1
                    )
                  )
                | '6' -> (
                    if String.unsafe_get s (pos+2) = '4' then (
                      1
                    )
                    else (
                      -1
                    )
                  )
                | _ -> (
                    -1
                  )
            )
            else (
              -1
            )
        in
        let i = Yojson.Safe.map_ident p f lb in
        Atdgen_runtime.Oj_run.read_until_field_value p lb;
        (
          match i with
            | 0 ->
              field_f32 := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_number
                  ) p lb
                )
              );
            | 1 ->
              field_f64 := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_number
                  ) p lb
                )
              );
            | _ -> (
                Yojson.Safe.skip_json p lb
              )
        );
      done;
      assert false;
    with Yojson.End_of_object -> (
        (
          {
            f32 = (match !field_f32 with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "f32");
            f64 = (match !field_f64 with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "f64");
          }
         : floats)
      )
)
let floats_of_string s =
  read_floats (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__17 = (
  Atdgen_runtime.Oj_run.write_list (
    Yojson.Safe.write_string
  )
)
let string_of__17 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__17 ob x;
  Bi_outbuf.contents ob
let read__17 = (
  Atdgen_runtime.Oj_run.read_list (
    Atdgen_runtime.Oj_run.read_string
  )
)
let _17_of_string s =
  read__17 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_extended_tuple = (
  fun ob x ->
    Bi_outbuf.add_char ob '[';
    (let x, _, _, _, _, _ = x in
    (
      Yojson.Safe.write_int
    ) ob x
    );
    Bi_outbuf.add_char ob ',';
    (let _, x, _, _, _, _ = x in
    (
      Yojson.Safe.write_std_float
    ) ob x
    );
    Bi_outbuf.add_char ob ',';
    (let _, _, x, _, _, _ = x in
    (
      Yojson.Safe.write_bool
    ) ob x
    );
    Bi_outbuf.add_char ob ',';
    (let _, _, _, x, _, _ = x in
    (
      write__4
    ) ob x
    );
    Bi_outbuf.add_char ob ',';
    (let _, _, _, _, x, _ = x in
    (
      Yojson.Safe.write_string
    ) ob x
    );
    Bi_outbuf.add_char ob ',';
    (let _, _, _, _, _, x = x in
    (
      write__17
    ) ob x
    );
    Bi_outbuf.add_char ob ']';
)
let string_of_extended_tuple ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_extended_tuple ob x;
  Bi_outbuf.contents ob
let read_extended_tuple = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    let std_tuple = Yojson.Safe.start_any_tuple p lb in
    let len = ref 0 in
    let end_of_tuple = ref false in
    (try
      let x0 =
        let x =
          (
            Atdgen_runtime.Oj_run.read_int
          ) p lb
        in
        incr len;
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_tuple_sep2 p std_tuple lb;
        x
      in
      let x1 =
        let x =
          (
            Atdgen_runtime.Oj_run.read_number
          ) p lb
        in
        incr len;
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_tuple_sep2 p std_tuple lb;
        x
      in
      let x2 =
        let x =
          (
            Atdgen_runtime.Oj_run.read_bool
          ) p lb
        in
        incr len;
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_tuple_sep2 p std_tuple lb;
        x
      in
      let x3 =
        let x =
          (
            read__4
          ) p lb
        in
        incr len;
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_tuple_sep2 p std_tuple lb;
        x
      in
      let x4 =
        let x =
          (
            Atdgen_runtime.Oj_run.read_string
          ) p lb
        in
        incr len;
        (try
          Yojson.Safe.read_space p lb;
          Yojson.Safe.read_tuple_sep2 p std_tuple lb;
        with Yojson.End_of_tuple -> end_of_tuple := true);
        x
      in
      let x5 =
        if !end_of_tuple then ([])
        else (
          let x = (
            (
              read__17
            ) p lb
          ) in
          incr len;
          (try
            Yojson.Safe.read_space p lb;
            Yojson.Safe.read_tuple_sep2 p std_tuple lb;
          with Yojson.End_of_tuple ->
            end_of_tuple := true);
          x
        )
      in
      if not !end_of_tuple then (
        try
          while true do
            Yojson.Safe.skip_json p lb;
            Yojson.Safe.read_space p lb;
            Yojson.Safe.read_tuple_sep2 p std_tuple lb;
          done
        with Yojson.End_of_tuple -> ()
      );
      (x0, x1, x2, x3, x4, x5)
    with Yojson.End_of_tuple ->
      Atdgen_runtime.Oj_run.missing_tuple_fields p !len [ 0; 1; 4 ]);
)
let extended_tuple_of_string s =
  read_extended_tuple (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_extended : _ -> extended -> _ = (
  fun ob (x : extended) ->
    Bi_outbuf.add_char ob '{';
    let is_first = ref true in
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"b0\":";
    (
      Yojson.Safe.write_int
    )
      ob x.b0x;
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"b1\":";
    (
      Yojson.Safe.write_bool
    )
      ob x.b1x;
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"b2\":";
    (
      Yojson.Safe.write_string
    )
      ob x.b2x;
    (match x.b3x with None -> () | Some x ->
      if !is_first then
        is_first := false
      else
        Bi_outbuf.add_char ob ',';
      Bi_outbuf.add_string ob "\"b3\":";
      (
        Yojson.Safe.write_string
      )
        ob x;
    );
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"b4\":";
    (
      write__6
    )
      ob x.b4x;
    if x.b5x <> 0.5 then (
      if !is_first then
        is_first := false
      else
        Bi_outbuf.add_char ob ',';
      Bi_outbuf.add_string ob "\"b5\":";
      (
        Yojson.Safe.write_std_float
      )
        ob x.b5x;
    );
    Bi_outbuf.add_char ob '}';
)
let string_of_extended ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_extended ob x;
  Bi_outbuf.contents ob
let read_extended = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    Yojson.Safe.read_lcurl p lb;
    let field_b0x = ref (None) in
    let field_b1x = ref (None) in
    let field_b2x = ref (None) in
    let field_b3x = ref (None) in
    let field_b4x = ref (None) in
    let field_b5x = ref (0.5) in
    try
      Yojson.Safe.read_space p lb;
      Yojson.Safe.read_object_end lb;
      Yojson.Safe.read_space p lb;
      let f =
        fun s pos len ->
          if pos < 0 || len < 0 || pos + len > String.length s then
            invalid_arg "out-of-bounds substring position or length";
          if len = 2 && String.unsafe_get s pos = 'b' then (
            match String.unsafe_get s (pos+1) with
              | '0' -> (
                  0
                )
              | '1' -> (
                  1
                )
              | '2' -> (
                  2
                )
              | '3' -> (
                  3
                )
              | '4' -> (
                  4
                )
              | '5' -> (
                  5
                )
              | _ -> (
                  -1
                )
          )
          else (
            -1
          )
      in
      let i = Yojson.Safe.map_ident p f lb in
      Atdgen_runtime.Oj_run.read_until_field_value p lb;
      (
        match i with
          | 0 ->
            field_b0x := (
              Some (
                (
                  Atdgen_runtime.Oj_run.read_int
                ) p lb
              )
            );
          | 1 ->
            field_b1x := (
              Some (
                (
                  Atdgen_runtime.Oj_run.read_bool
                ) p lb
              )
            );
          | 2 ->
            field_b2x := (
              Some (
                (
                  Atdgen_runtime.Oj_run.read_string
                ) p lb
              )
            );
          | 3 ->
            if not (Yojson.Safe.read_null_if_possible p lb) then (
              field_b3x := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_string
                  ) p lb
                )
              );
            )
          | 4 ->
            field_b4x := (
              Some (
                (
                  read__6
                ) p lb
              )
            );
          | 5 ->
            if not (Yojson.Safe.read_null_if_possible p lb) then (
              field_b5x := (
                (
                  Atdgen_runtime.Oj_run.read_number
                ) p lb
              );
            )
          | _ -> (
              Yojson.Safe.skip_json p lb
            )
      );
      while true do
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_object_sep p lb;
        Yojson.Safe.read_space p lb;
        let f =
          fun s pos len ->
            if pos < 0 || len < 0 || pos + len > String.length s then
              invalid_arg "out-of-bounds substring position or length";
            if len = 2 && String.unsafe_get s pos = 'b' then (
              match String.unsafe_get s (pos+1) with
                | '0' -> (
                    0
                  )
                | '1' -> (
                    1
                  )
                | '2' -> (
                    2
                  )
                | '3' -> (
                    3
                  )
                | '4' -> (
                    4
                  )
                | '5' -> (
                    5
                  )
                | _ -> (
                    -1
                  )
            )
            else (
              -1
            )
        in
        let i = Yojson.Safe.map_ident p f lb in
        Atdgen_runtime.Oj_run.read_until_field_value p lb;
        (
          match i with
            | 0 ->
              field_b0x := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_int
                  ) p lb
                )
              );
            | 1 ->
              field_b1x := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_bool
                  ) p lb
                )
              );
            | 2 ->
              field_b2x := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_string
                  ) p lb
                )
              );
            | 3 ->
              if not (Yojson.Safe.read_null_if_possible p lb) then (
                field_b3x := (
                  Some (
                    (
                      Atdgen_runtime.Oj_run.read_string
                    ) p lb
                  )
                );
              )
            | 4 ->
              field_b4x := (
                Some (
                  (
                    read__6
                  ) p lb
                )
              );
            | 5 ->
              if not (Yojson.Safe.read_null_if_possible p lb) then (
                field_b5x := (
                  (
                    Atdgen_runtime.Oj_run.read_number
                  ) p lb
                );
              )
            | _ -> (
                Yojson.Safe.skip_json p lb
              )
        );
      done;
      assert false;
    with Yojson.End_of_object -> (
        (
          {
            b0x = (match !field_b0x with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "b0x");
            b1x = (match !field_b1x with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "b1x");
            b2x = (match !field_b2x with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "b2x");
            b3x = !field_b3x;
            b4x = (match !field_b4x with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "b4x");
            b5x = !field_b5x;
          }
         : extended)
      )
)
let extended_of_string s =
  read_extended (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__27 = (
  fun ob x -> (
    let x = ( Test_lib.Even_natural.unwrap ) x in (
      write_natural
    ) ob x)
)
let string_of__27 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__27 ob x;
  Bi_outbuf.contents ob
let read__27 = (
  fun p lb ->
    let x = (
      read_natural
    ) p lb in
    ( Test_lib.Even_natural.wrap ) x
)
let _27_of_string s =
  read__27 (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_even_natural = (
  write__27
)
let string_of_even_natural ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_even_natural ob x;
  Bi_outbuf.contents ob
let read_even_natural = (
  read__27
)
let even_natural_of_string s =
  read_even_natural (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_def = (
  Test_lib.Json.write_def
)
let string_of_def ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_def ob x;
  Bi_outbuf.contents ob
let read_def = (
  Test_lib.Json.read_def
)
let def_of_string s =
  read_def (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_char = (
  Atdgen_runtime.Oj_run.write_int8
)
let string_of_char ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_char ob x;
  Bi_outbuf.contents ob
let read_char = (
  Atdgen_runtime.Oj_run.read_int8
)
let char_of_string s =
  read_char (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_base_tuple = (
  fun ob x ->
    Bi_outbuf.add_char ob '[';
    (let x, _ = x in
    (
      Yojson.Safe.write_int
    ) ob x
    );
    Bi_outbuf.add_char ob ',';
    (let _, x = x in
    (
      Yojson.Safe.write_std_float
    ) ob x
    );
    Bi_outbuf.add_char ob ']';
)
let string_of_base_tuple ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_base_tuple ob x;
  Bi_outbuf.contents ob
let read_base_tuple = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    let std_tuple = Yojson.Safe.start_any_tuple p lb in
    let len = ref 0 in
    let end_of_tuple = ref false in
    (try
      let x0 =
        let x =
          (
            Atdgen_runtime.Oj_run.read_int
          ) p lb
        in
        incr len;
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_tuple_sep2 p std_tuple lb;
        x
      in
      let x1 =
        let x =
          (
            Atdgen_runtime.Oj_run.read_number
          ) p lb
        in
        incr len;
        (try
          Yojson.Safe.read_space p lb;
          Yojson.Safe.read_tuple_sep2 p std_tuple lb;
        with Yojson.End_of_tuple -> end_of_tuple := true);
        x
      in
      if not !end_of_tuple then (
        try
          while true do
            Yojson.Safe.skip_json p lb;
            Yojson.Safe.read_space p lb;
            Yojson.Safe.read_tuple_sep2 p std_tuple lb;
          done
        with Yojson.End_of_tuple -> ()
      );
      (x0, x1)
    with Yojson.End_of_tuple ->
      Atdgen_runtime.Oj_run.missing_tuple_fields p !len [ 0; 1 ]);
)
let base_tuple_of_string s =
  read_base_tuple (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_base : _ -> base -> _ = (
  fun ob (x : base) ->
    Bi_outbuf.add_char ob '{';
    let is_first = ref true in
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"b0\":";
    (
      Yojson.Safe.write_int
    )
      ob x.b0;
    if !is_first then
      is_first := false
    else
      Bi_outbuf.add_char ob ',';
    Bi_outbuf.add_string ob "\"b1\":";
    (
      Yojson.Safe.write_bool
    )
      ob x.b1;
    Bi_outbuf.add_char ob '}';
)
let string_of_base ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_base ob x;
  Bi_outbuf.contents ob
let read_base = (
  fun p lb ->
    Yojson.Safe.read_space p lb;
    Yojson.Safe.read_lcurl p lb;
    let field_b0 = ref (None) in
    let field_b1 = ref (None) in
    try
      Yojson.Safe.read_space p lb;
      Yojson.Safe.read_object_end lb;
      Yojson.Safe.read_space p lb;
      let f =
        fun s pos len ->
          if pos < 0 || len < 0 || pos + len > String.length s then
            invalid_arg "out-of-bounds substring position or length";
          if len = 2 && String.unsafe_get s pos = 'b' then (
            match String.unsafe_get s (pos+1) with
              | '0' -> (
                  0
                )
              | '1' -> (
                  1
                )
              | _ -> (
                  -1
                )
          )
          else (
            -1
          )
      in
      let i = Yojson.Safe.map_ident p f lb in
      Atdgen_runtime.Oj_run.read_until_field_value p lb;
      (
        match i with
          | 0 ->
            field_b0 := (
              Some (
                (
                  Atdgen_runtime.Oj_run.read_int
                ) p lb
              )
            );
          | 1 ->
            field_b1 := (
              Some (
                (
                  Atdgen_runtime.Oj_run.read_bool
                ) p lb
              )
            );
          | _ -> (
              Yojson.Safe.skip_json p lb
            )
      );
      while true do
        Yojson.Safe.read_space p lb;
        Yojson.Safe.read_object_sep p lb;
        Yojson.Safe.read_space p lb;
        let f =
          fun s pos len ->
            if pos < 0 || len < 0 || pos + len > String.length s then
              invalid_arg "out-of-bounds substring position or length";
            if len = 2 && String.unsafe_get s pos = 'b' then (
              match String.unsafe_get s (pos+1) with
                | '0' -> (
                    0
                  )
                | '1' -> (
                    1
                  )
                | _ -> (
                    -1
                  )
            )
            else (
              -1
            )
        in
        let i = Yojson.Safe.map_ident p f lb in
        Atdgen_runtime.Oj_run.read_until_field_value p lb;
        (
          match i with
            | 0 ->
              field_b0 := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_int
                  ) p lb
                )
              );
            | 1 ->
              field_b1 := (
                Some (
                  (
                    Atdgen_runtime.Oj_run.read_bool
                  ) p lb
                )
              );
            | _ -> (
                Yojson.Safe.skip_json p lb
              )
        );
      done;
      assert false;
    with Yojson.End_of_object -> (
        (
          {
            b0 = (match !field_b0 with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "b0");
            b1 = (match !field_b1 with Some x -> x | None -> Atdgen_runtime.Oj_run.missing_field p "b1");
          }
         : base)
      )
)
let base_of_string s =
  read_base (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write__23 write__a = (
  Atdgen_runtime.Oj_run.write_array (
    write__a
  )
)
let string_of__23 write__a ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__23 write__a ob x;
  Bi_outbuf.contents ob
let read__23 read__a = (
  Atdgen_runtime.Oj_run.read_array (
    read__a
  )
)
let _23_of_string read__a s =
  read__23 read__a (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_array write__a = (
  write__23 write__a
)
let string_of_array write__a ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_array write__a ob x;
  Bi_outbuf.contents ob
let read_array read__a = (
  read__23 read__a
)
let array_of_string read__a s =
  read_array read__a (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_abs3 write__a = (
  write__19 write__a
)
let string_of_abs3 write__a ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_abs3 write__a ob x;
  Bi_outbuf.contents ob
let read_abs3 read__a = (
  read__19 read__a
)
let abs3_of_string read__a s =
  read_abs3 read__a (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_abs2 write__a = (
  write__19 write__a
)
let string_of_abs2 write__a ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_abs2 write__a ob x;
  Bi_outbuf.contents ob
let read_abs2 read__a = (
  read__19 read__a
)
let abs2_of_string read__a s =
  read_abs2 read__a (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let write_abs1 write__a = (
  write__19 write__a
)
let string_of_abs1 write__a ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_abs1 write__a ob x;
  Bi_outbuf.contents ob
let read_abs1 read__a = (
  read__19 read__a
)
let abs1_of_string read__a s =
  read_abs1 read__a (Yojson.Safe.init_lexer ()) (Lexing.from_string s)
let create_r 
  ~a
  ~b
  ~c
  () : r =
  {
    a = a;
    b = b;
    c = c;
  }
let create_poly 
  ~fst
  ~snd
  () : ('x, 'y) poly =
  {
    fst = fst;
    snd = snd;
  }
let create_val1 
  ~val1_x
  () : val1 =
  {
    val1_x = val1_x;
  }
let create_val2 
  ~val2_x
  ?val2_y
  () : val2 =
  {
    val2_x = val2_x;
    val2_y = val2_y;
  }
let create_mixed_record 
  ?field0
  ?field1
  ~field2
  ~field3
  ~field4
  ?field5
  ?field6
  ~field7
  ~field8
  ~field9
  ~field10
  ?(field11 = false)
  ~field12
  ~field13
  ~field14
  () : mixed_record =
  {
    field0 = field0;
    field1 = field1;
    field2 = field2;
    field3 = field3;
    field4 = field4;
    field5 = field5;
    field6 = field6;
    field7 = field7;
    field8 = field8;
    field9 = field9;
    field10 = field10;
    field11 = field11;
    field12 = field12;
    field13 = field13;
    field14 = field14;
  }
let create_test 
  ?x0
  ?x1
  ~x2
  ~x3
  ~x4
  () : test =
  {
    x0 = x0;
    x1 = x1;
    x2 = x2;
    x3 = x3;
    x4 = x4;
  }
let create_some_record 
  ~some_field
  () : some_record =
  {
    some_field = some_field;
  }
let create_precision 
  ~sqrt2_5
  ~small_2
  ~large_2
  () : precision =
  {
    sqrt2_5 = sqrt2_5;
    small_2 = small_2;
    large_2 = large_2;
  }
let create_generic 
  ~x294623
  () : 'a generic =
  {
    x294623 = x294623;
  }
let create_floats 
  ~f32
  ~f64
  () : floats =
  {
    f32 = f32;
    f64 = f64;
  }
let create_extended 
  ~b0x
  ~b1x
  ~b2x
  ?b3x
  ~b4x
  ?(b5x = 0.5)
  () : extended =
  {
    b0x = b0x;
    b1x = b1x;
    b2x = b2x;
    b3x = b3x;
    b4x = b4x;
    b5x = b5x;
  }
let create_base 
  ~b0
  ~b1
  () : base =
  {
    b0 = b0;
    b1 = b1;
  }
atd-2.1.0/atdgen/test/testjstd.expected.mli000066400000000000000000000766101357165332000206710ustar00rootroot00000000000000(* Auto-generated from "test.atd" *)
[@@@ocaml.warning "-27-32-35-39"]

(** This is just a test. *)

type test_variant = Test.test_variant

type ('x, 'y) poly = ('x, 'y) Test.poly = {
  fst: 'x list;
  snd: ('x, 'y) poly option
}

type 'a p' = 'a Test.p' =  A | Bb of 'a p' | Ccccc of 'a 

type p = Test.p

and r = Test.r = { a: int; mutable b: bool; c: p }

type validated_string_check = Test.validated_string_check

type validate_me = Test.validate_me

type val1 = Test.val1 = { val1_x: int }

type val2 = Test.val2 = { val2_x: val1; val2_y: val1 option }

type unixtime_list = Test.unixtime_list

type date = Test.date

type mixed_record = Test.mixed_record = {
  field0: int option;
  field1: float option;
  field2: string option;
  field3: Int64.t;
  field4: float Atdgen_runtime.Util.ocaml_array;
  field5: bool option;
  field6: string option;
  field7: test_variant;
  field8: string Atdgen_runtime.Util.ocaml_array;
  field9: (int * int * Char.t * int * Int32.t * Int64.t);
  field10: bool;
  field11: bool;
  field12: unit list;
  field13: string option list;
  field14: date
}

type mixed = Test.mixed

type test = Test.test = {
  x0: int option;
  x1: float option;
  x2: mixed;
  x3: mixed_record list;
  x4: Int64.t
}

type tup = Test.tup

type star_rating = Test.star_rating

type 'a generic = 'a Test.generic = { x294623: int }

type specialized = Test.specialized

type some_record = Test.some_record = { some_field: int }

type precision = Test.precision = {
  sqrt2_5: float;
  small_2: float;
  large_2: float
}

type p'' = Test.p''

type option_validation = Test.option_validation

type no_real_wrap = Test.no_real_wrap

type natural = Test.natural

type id = Test.id

type json_map = Test.json_map

type intopt = Test.intopt

type int_assoc_list = Test.int_assoc_list

type int_assoc_array = Test.int_assoc_array

type int8 = Test.int8

type int64 = Test.int64

type int32 = Test.int32

type hello = Test.hello

type floats = Test.floats = { f32: float; f64: float }

type extended_tuple = Test.extended_tuple

type extended = Test.extended = {
  b0x (*atd b0 *): int;
  b1x (*atd b1 *): bool;
  b2x (*atd b2 *): string;
  b3x (*atd b3 *): string option;
  b4x (*atd b4 *): string option;
  b5x (*atd b5 *): float
}

type even_natural = Test.even_natural

(**
  \}\}\}abc[def]ghi
  
{v
j  *  j
 k * k
  l*l
v}
  
{v
mno
v}
  
  [pqr]\{stu\}vwx
  
  yz
  
  [\} \[ \] \{v]
  
{v
\} [x] v\} \{v [ @ 
v}
*)
type def = Test_lib.Json.def

type char = Test.char

type base_tuple = Test.base_tuple

type base = Test.base = { b0: int; b1: bool }

type 'a array = 'a Test.array

type 'a abs3 = 'a Test.abs3

type 'a abs2 = 'a Test.abs2

type 'a abs1 = 'a Test.abs1

val write_test_variant :
  Bi_outbuf.t -> test_variant -> unit
  (** Output a JSON value of type {!test_variant}. *)

val string_of_test_variant :
  ?len:int -> test_variant -> string
  (** Serialize a value of type {!test_variant}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_test_variant :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> test_variant
  (** Input JSON data of type {!test_variant}. *)

val test_variant_of_string :
  string -> test_variant
  (** Deserialize JSON data of type {!test_variant}. *)


val write_poly :
  (Bi_outbuf.t -> 'x -> unit) ->
  (Bi_outbuf.t -> 'y -> unit) ->
  Bi_outbuf.t -> ('x, 'y) poly -> unit
  (** Output a JSON value of type {!poly}. *)

val string_of_poly :
  (Bi_outbuf.t -> 'x -> unit) ->
  (Bi_outbuf.t -> 'y -> unit) ->
  ?len:int -> ('x, 'y) poly -> string
  (** Serialize a value of type {!poly}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_poly :
  (Yojson.Safe.lexer_state -> Lexing.lexbuf -> 'x) ->
  (Yojson.Safe.lexer_state -> Lexing.lexbuf -> 'y) ->
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> ('x, 'y) poly
  (** Input JSON data of type {!poly}. *)

val poly_of_string :
  (Yojson.Safe.lexer_state -> Lexing.lexbuf -> 'x) ->
  (Yojson.Safe.lexer_state -> Lexing.lexbuf -> 'y) ->
  string -> ('x, 'y) poly
  (** Deserialize JSON data of type {!poly}. *)

val create_poly :
  fst: 'x list ->
  snd: ('x, 'y) poly option ->
  unit -> ('x, 'y) poly
  (** Create a record of type {!poly}. *)


val write_p' :
  (Bi_outbuf.t -> 'a -> unit) ->
  Bi_outbuf.t -> 'a p' -> unit
  (** Output a JSON value of type {!p'}. *)

val string_of_p' :
  (Bi_outbuf.t -> 'a -> unit) ->
  ?len:int -> 'a p' -> string
  (** Serialize a value of type {!p'}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_p' :
  (Yojson.Safe.lexer_state -> Lexing.lexbuf -> 'a) ->
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> 'a p'
  (** Input JSON data of type {!p'}. *)

val p'_of_string :
  (Yojson.Safe.lexer_state -> Lexing.lexbuf -> 'a) ->
  string -> 'a p'
  (** Deserialize JSON data of type {!p'}. *)


val write_p :
  Bi_outbuf.t -> p -> unit
  (** Output a JSON value of type {!p}. *)

val string_of_p :
  ?len:int -> p -> string
  (** Serialize a value of type {!p}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_p :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> p
  (** Input JSON data of type {!p}. *)

val p_of_string :
  string -> p
  (** Deserialize JSON data of type {!p}. *)


val write_r :
  Bi_outbuf.t -> r -> unit
  (** Output a JSON value of type {!r}. *)

val string_of_r :
  ?len:int -> r -> string
  (** Serialize a value of type {!r}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_r :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> r
  (** Input JSON data of type {!r}. *)

val r_of_string :
  string -> r
  (** Deserialize JSON data of type {!r}. *)

val create_r :
  a: int ->
  b: bool ->
  c: p ->
  unit -> r
  (** Create a record of type {!r}. *)


val write_validated_string_check :
  Bi_outbuf.t -> validated_string_check -> unit
  (** Output a JSON value of type {!validated_string_check}. *)

val string_of_validated_string_check :
  ?len:int -> validated_string_check -> string
  (** Serialize a value of type {!validated_string_check}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_validated_string_check :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> validated_string_check
  (** Input JSON data of type {!validated_string_check}. *)

val validated_string_check_of_string :
  string -> validated_string_check
  (** Deserialize JSON data of type {!validated_string_check}. *)


val write_validate_me :
  Bi_outbuf.t -> validate_me -> unit
  (** Output a JSON value of type {!validate_me}. *)

val string_of_validate_me :
  ?len:int -> validate_me -> string
  (** Serialize a value of type {!validate_me}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_validate_me :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> validate_me
  (** Input JSON data of type {!validate_me}. *)

val validate_me_of_string :
  string -> validate_me
  (** Deserialize JSON data of type {!validate_me}. *)


val write_val1 :
  Bi_outbuf.t -> val1 -> unit
  (** Output a JSON value of type {!val1}. *)

val string_of_val1 :
  ?len:int -> val1 -> string
  (** Serialize a value of type {!val1}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_val1 :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> val1
  (** Input JSON data of type {!val1}. *)

val val1_of_string :
  string -> val1
  (** Deserialize JSON data of type {!val1}. *)

val create_val1 :
  val1_x: int ->
  unit -> val1
  (** Create a record of type {!val1}. *)


val write_val2 :
  Bi_outbuf.t -> val2 -> unit
  (** Output a JSON value of type {!val2}. *)

val string_of_val2 :
  ?len:int -> val2 -> string
  (** Serialize a value of type {!val2}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_val2 :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> val2
  (** Input JSON data of type {!val2}. *)

val val2_of_string :
  string -> val2
  (** Deserialize JSON data of type {!val2}. *)

val create_val2 :
  val2_x: val1 ->
  ?val2_y: val1 ->
  unit -> val2
  (** Create a record of type {!val2}. *)


val write_unixtime_list :
  Bi_outbuf.t -> unixtime_list -> unit
  (** Output a JSON value of type {!unixtime_list}. *)

val string_of_unixtime_list :
  ?len:int -> unixtime_list -> string
  (** Serialize a value of type {!unixtime_list}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_unixtime_list :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> unixtime_list
  (** Input JSON data of type {!unixtime_list}. *)

val unixtime_list_of_string :
  string -> unixtime_list
  (** Deserialize JSON data of type {!unixtime_list}. *)


val write_date :
  Bi_outbuf.t -> date -> unit
  (** Output a JSON value of type {!date}. *)

val string_of_date :
  ?len:int -> date -> string
  (** Serialize a value of type {!date}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_date :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> date
  (** Input JSON data of type {!date}. *)

val date_of_string :
  string -> date
  (** Deserialize JSON data of type {!date}. *)


val write_mixed_record :
  Bi_outbuf.t -> mixed_record -> unit
  (** Output a JSON value of type {!mixed_record}. *)

val string_of_mixed_record :
  ?len:int -> mixed_record -> string
  (** Serialize a value of type {!mixed_record}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_mixed_record :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> mixed_record
  (** Input JSON data of type {!mixed_record}. *)

val mixed_record_of_string :
  string -> mixed_record
  (** Deserialize JSON data of type {!mixed_record}. *)

val create_mixed_record :
  ?field0: int ->
  ?field1: float ->
  field2: string option ->
  field3: Int64.t ->
  field4: float Atdgen_runtime.Util.ocaml_array ->
  ?field5: bool ->
  ?field6: string ->
  field7: test_variant ->
  field8: string Atdgen_runtime.Util.ocaml_array ->
  field9: (int * int * Char.t * int * Int32.t * Int64.t) ->
  field10: bool ->
  ?field11: bool ->
  field12: unit list ->
  field13: string option list ->
  field14: date ->
  unit -> mixed_record
  (** Create a record of type {!mixed_record}. *)


val write_mixed :
  Bi_outbuf.t -> mixed -> unit
  (** Output a JSON value of type {!mixed}. *)

val string_of_mixed :
  ?len:int -> mixed -> string
  (** Serialize a value of type {!mixed}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_mixed :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> mixed
  (** Input JSON data of type {!mixed}. *)

val mixed_of_string :
  string -> mixed
  (** Deserialize JSON data of type {!mixed}. *)


val write_test :
  Bi_outbuf.t -> test -> unit
  (** Output a JSON value of type {!test}. *)

val string_of_test :
  ?len:int -> test -> string
  (** Serialize a value of type {!test}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_test :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> test
  (** Input JSON data of type {!test}. *)

val test_of_string :
  string -> test
  (** Deserialize JSON data of type {!test}. *)

val create_test :
  ?x0: int ->
  ?x1: float ->
  x2: mixed ->
  x3: mixed_record list ->
  x4: Int64.t ->
  unit -> test
  (** Create a record of type {!test}. *)


val write_tup :
  Bi_outbuf.t -> tup -> unit
  (** Output a JSON value of type {!tup}. *)

val string_of_tup :
  ?len:int -> tup -> string
  (** Serialize a value of type {!tup}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_tup :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> tup
  (** Input JSON data of type {!tup}. *)

val tup_of_string :
  string -> tup
  (** Deserialize JSON data of type {!tup}. *)


val write_star_rating :
  Bi_outbuf.t -> star_rating -> unit
  (** Output a JSON value of type {!star_rating}. *)

val string_of_star_rating :
  ?len:int -> star_rating -> string
  (** Serialize a value of type {!star_rating}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_star_rating :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> star_rating
  (** Input JSON data of type {!star_rating}. *)

val star_rating_of_string :
  string -> star_rating
  (** Deserialize JSON data of type {!star_rating}. *)


val write_generic :
  (Bi_outbuf.t -> 'a -> unit) ->
  Bi_outbuf.t -> 'a generic -> unit
  (** Output a JSON value of type {!generic}. *)

val string_of_generic :
  (Bi_outbuf.t -> 'a -> unit) ->
  ?len:int -> 'a generic -> string
  (** Serialize a value of type {!generic}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_generic :
  (Yojson.Safe.lexer_state -> Lexing.lexbuf -> 'a) ->
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> 'a generic
  (** Input JSON data of type {!generic}. *)

val generic_of_string :
  (Yojson.Safe.lexer_state -> Lexing.lexbuf -> 'a) ->
  string -> 'a generic
  (** Deserialize JSON data of type {!generic}. *)

val create_generic :
  x294623: int ->
  unit -> 'a generic
  (** Create a record of type {!generic}. *)


val write_specialized :
  Bi_outbuf.t -> specialized -> unit
  (** Output a JSON value of type {!specialized}. *)

val string_of_specialized :
  ?len:int -> specialized -> string
  (** Serialize a value of type {!specialized}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_specialized :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> specialized
  (** Input JSON data of type {!specialized}. *)

val specialized_of_string :
  string -> specialized
  (** Deserialize JSON data of type {!specialized}. *)


val write_some_record :
  Bi_outbuf.t -> some_record -> unit
  (** Output a JSON value of type {!some_record}. *)

val string_of_some_record :
  ?len:int -> some_record -> string
  (** Serialize a value of type {!some_record}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_some_record :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> some_record
  (** Input JSON data of type {!some_record}. *)

val some_record_of_string :
  string -> some_record
  (** Deserialize JSON data of type {!some_record}. *)

val create_some_record :
  some_field: int ->
  unit -> some_record
  (** Create a record of type {!some_record}. *)


val write_precision :
  Bi_outbuf.t -> precision -> unit
  (** Output a JSON value of type {!precision}. *)

val string_of_precision :
  ?len:int -> precision -> string
  (** Serialize a value of type {!precision}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_precision :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> precision
  (** Input JSON data of type {!precision}. *)

val precision_of_string :
  string -> precision
  (** Deserialize JSON data of type {!precision}. *)

val create_precision :
  sqrt2_5: float ->
  small_2: float ->
  large_2: float ->
  unit -> precision
  (** Create a record of type {!precision}. *)


val write_p'' :
  Bi_outbuf.t -> p'' -> unit
  (** Output a JSON value of type {!p''}. *)

val string_of_p'' :
  ?len:int -> p'' -> string
  (** Serialize a value of type {!p''}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_p'' :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> p''
  (** Input JSON data of type {!p''}. *)

val p''_of_string :
  string -> p''
  (** Deserialize JSON data of type {!p''}. *)


val write_option_validation :
  Bi_outbuf.t -> option_validation -> unit
  (** Output a JSON value of type {!option_validation}. *)

val string_of_option_validation :
  ?len:int -> option_validation -> string
  (** Serialize a value of type {!option_validation}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_option_validation :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> option_validation
  (** Input JSON data of type {!option_validation}. *)

val option_validation_of_string :
  string -> option_validation
  (** Deserialize JSON data of type {!option_validation}. *)


val write_no_real_wrap :
  Bi_outbuf.t -> no_real_wrap -> unit
  (** Output a JSON value of type {!no_real_wrap}. *)

val string_of_no_real_wrap :
  ?len:int -> no_real_wrap -> string
  (** Serialize a value of type {!no_real_wrap}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_no_real_wrap :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> no_real_wrap
  (** Input JSON data of type {!no_real_wrap}. *)

val no_real_wrap_of_string :
  string -> no_real_wrap
  (** Deserialize JSON data of type {!no_real_wrap}. *)


val write_natural :
  Bi_outbuf.t -> natural -> unit
  (** Output a JSON value of type {!natural}. *)

val string_of_natural :
  ?len:int -> natural -> string
  (** Serialize a value of type {!natural}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_natural :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> natural
  (** Input JSON data of type {!natural}. *)

val natural_of_string :
  string -> natural
  (** Deserialize JSON data of type {!natural}. *)


val write_id :
  Bi_outbuf.t -> id -> unit
  (** Output a JSON value of type {!id}. *)

val string_of_id :
  ?len:int -> id -> string
  (** Serialize a value of type {!id}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_id :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> id
  (** Input JSON data of type {!id}. *)

val id_of_string :
  string -> id
  (** Deserialize JSON data of type {!id}. *)


val write_json_map :
  Bi_outbuf.t -> json_map -> unit
  (** Output a JSON value of type {!json_map}. *)

val string_of_json_map :
  ?len:int -> json_map -> string
  (** Serialize a value of type {!json_map}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_json_map :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> json_map
  (** Input JSON data of type {!json_map}. *)

val json_map_of_string :
  string -> json_map
  (** Deserialize JSON data of type {!json_map}. *)


val write_intopt :
  Bi_outbuf.t -> intopt -> unit
  (** Output a JSON value of type {!intopt}. *)

val string_of_intopt :
  ?len:int -> intopt -> string
  (** Serialize a value of type {!intopt}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_intopt :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> intopt
  (** Input JSON data of type {!intopt}. *)

val intopt_of_string :
  string -> intopt
  (** Deserialize JSON data of type {!intopt}. *)


val write_int_assoc_list :
  Bi_outbuf.t -> int_assoc_list -> unit
  (** Output a JSON value of type {!int_assoc_list}. *)

val string_of_int_assoc_list :
  ?len:int -> int_assoc_list -> string
  (** Serialize a value of type {!int_assoc_list}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_int_assoc_list :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> int_assoc_list
  (** Input JSON data of type {!int_assoc_list}. *)

val int_assoc_list_of_string :
  string -> int_assoc_list
  (** Deserialize JSON data of type {!int_assoc_list}. *)


val write_int_assoc_array :
  Bi_outbuf.t -> int_assoc_array -> unit
  (** Output a JSON value of type {!int_assoc_array}. *)

val string_of_int_assoc_array :
  ?len:int -> int_assoc_array -> string
  (** Serialize a value of type {!int_assoc_array}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_int_assoc_array :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> int_assoc_array
  (** Input JSON data of type {!int_assoc_array}. *)

val int_assoc_array_of_string :
  string -> int_assoc_array
  (** Deserialize JSON data of type {!int_assoc_array}. *)


val write_int8 :
  Bi_outbuf.t -> int8 -> unit
  (** Output a JSON value of type {!int8}. *)

val string_of_int8 :
  ?len:int -> int8 -> string
  (** Serialize a value of type {!int8}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_int8 :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> int8
  (** Input JSON data of type {!int8}. *)

val int8_of_string :
  string -> int8
  (** Deserialize JSON data of type {!int8}. *)


val write_int64 :
  Bi_outbuf.t -> int64 -> unit
  (** Output a JSON value of type {!int64}. *)

val string_of_int64 :
  ?len:int -> int64 -> string
  (** Serialize a value of type {!int64}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_int64 :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> int64
  (** Input JSON data of type {!int64}. *)

val int64_of_string :
  string -> int64
  (** Deserialize JSON data of type {!int64}. *)


val write_int32 :
  Bi_outbuf.t -> int32 -> unit
  (** Output a JSON value of type {!int32}. *)

val string_of_int32 :
  ?len:int -> int32 -> string
  (** Serialize a value of type {!int32}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_int32 :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> int32
  (** Input JSON data of type {!int32}. *)

val int32_of_string :
  string -> int32
  (** Deserialize JSON data of type {!int32}. *)


val write_hello :
  Bi_outbuf.t -> hello -> unit
  (** Output a JSON value of type {!hello}. *)

val string_of_hello :
  ?len:int -> hello -> string
  (** Serialize a value of type {!hello}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_hello :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> hello
  (** Input JSON data of type {!hello}. *)

val hello_of_string :
  string -> hello
  (** Deserialize JSON data of type {!hello}. *)


val write_floats :
  Bi_outbuf.t -> floats -> unit
  (** Output a JSON value of type {!floats}. *)

val string_of_floats :
  ?len:int -> floats -> string
  (** Serialize a value of type {!floats}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_floats :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> floats
  (** Input JSON data of type {!floats}. *)

val floats_of_string :
  string -> floats
  (** Deserialize JSON data of type {!floats}. *)

val create_floats :
  f32: float ->
  f64: float ->
  unit -> floats
  (** Create a record of type {!floats}. *)


val write_extended_tuple :
  Bi_outbuf.t -> extended_tuple -> unit
  (** Output a JSON value of type {!extended_tuple}. *)

val string_of_extended_tuple :
  ?len:int -> extended_tuple -> string
  (** Serialize a value of type {!extended_tuple}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_extended_tuple :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> extended_tuple
  (** Input JSON data of type {!extended_tuple}. *)

val extended_tuple_of_string :
  string -> extended_tuple
  (** Deserialize JSON data of type {!extended_tuple}. *)


val write_extended :
  Bi_outbuf.t -> extended -> unit
  (** Output a JSON value of type {!extended}. *)

val string_of_extended :
  ?len:int -> extended -> string
  (** Serialize a value of type {!extended}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_extended :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> extended
  (** Input JSON data of type {!extended}. *)

val extended_of_string :
  string -> extended
  (** Deserialize JSON data of type {!extended}. *)

val create_extended :
  b0x: int ->
  b1x: bool ->
  b2x: string ->
  ?b3x: string ->
  b4x: string option ->
  ?b5x: float ->
  unit -> extended
  (** Create a record of type {!extended}. *)


val write_even_natural :
  Bi_outbuf.t -> even_natural -> unit
  (** Output a JSON value of type {!even_natural}. *)

val string_of_even_natural :
  ?len:int -> even_natural -> string
  (** Serialize a value of type {!even_natural}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_even_natural :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> even_natural
  (** Input JSON data of type {!even_natural}. *)

val even_natural_of_string :
  string -> even_natural
  (** Deserialize JSON data of type {!even_natural}. *)


val write_def :
  Bi_outbuf.t -> def -> unit
  (** Output a JSON value of type {!def}. *)

val string_of_def :
  ?len:int -> def -> string
  (** Serialize a value of type {!def}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_def :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> def
  (** Input JSON data of type {!def}. *)

val def_of_string :
  string -> def
  (** Deserialize JSON data of type {!def}. *)


val write_char :
  Bi_outbuf.t -> char -> unit
  (** Output a JSON value of type {!char}. *)

val string_of_char :
  ?len:int -> char -> string
  (** Serialize a value of type {!char}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_char :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> char
  (** Input JSON data of type {!char}. *)

val char_of_string :
  string -> char
  (** Deserialize JSON data of type {!char}. *)


val write_base_tuple :
  Bi_outbuf.t -> base_tuple -> unit
  (** Output a JSON value of type {!base_tuple}. *)

val string_of_base_tuple :
  ?len:int -> base_tuple -> string
  (** Serialize a value of type {!base_tuple}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_base_tuple :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> base_tuple
  (** Input JSON data of type {!base_tuple}. *)

val base_tuple_of_string :
  string -> base_tuple
  (** Deserialize JSON data of type {!base_tuple}. *)


val write_base :
  Bi_outbuf.t -> base -> unit
  (** Output a JSON value of type {!base}. *)

val string_of_base :
  ?len:int -> base -> string
  (** Serialize a value of type {!base}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_base :
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> base
  (** Input JSON data of type {!base}. *)

val base_of_string :
  string -> base
  (** Deserialize JSON data of type {!base}. *)

val create_base :
  b0: int ->
  b1: bool ->
  unit -> base
  (** Create a record of type {!base}. *)


val write_array :
  (Bi_outbuf.t -> 'a -> unit) ->
  Bi_outbuf.t -> 'a array -> unit
  (** Output a JSON value of type {!array}. *)

val string_of_array :
  (Bi_outbuf.t -> 'a -> unit) ->
  ?len:int -> 'a array -> string
  (** Serialize a value of type {!array}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_array :
  (Yojson.Safe.lexer_state -> Lexing.lexbuf -> 'a) ->
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> 'a array
  (** Input JSON data of type {!array}. *)

val array_of_string :
  (Yojson.Safe.lexer_state -> Lexing.lexbuf -> 'a) ->
  string -> 'a array
  (** Deserialize JSON data of type {!array}. *)


val write_abs3 :
  (Bi_outbuf.t -> 'a -> unit) ->
  Bi_outbuf.t -> 'a abs3 -> unit
  (** Output a JSON value of type {!abs3}. *)

val string_of_abs3 :
  (Bi_outbuf.t -> 'a -> unit) ->
  ?len:int -> 'a abs3 -> string
  (** Serialize a value of type {!abs3}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_abs3 :
  (Yojson.Safe.lexer_state -> Lexing.lexbuf -> 'a) ->
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> 'a abs3
  (** Input JSON data of type {!abs3}. *)

val abs3_of_string :
  (Yojson.Safe.lexer_state -> Lexing.lexbuf -> 'a) ->
  string -> 'a abs3
  (** Deserialize JSON data of type {!abs3}. *)


val write_abs2 :
  (Bi_outbuf.t -> 'a -> unit) ->
  Bi_outbuf.t -> 'a abs2 -> unit
  (** Output a JSON value of type {!abs2}. *)

val string_of_abs2 :
  (Bi_outbuf.t -> 'a -> unit) ->
  ?len:int -> 'a abs2 -> string
  (** Serialize a value of type {!abs2}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_abs2 :
  (Yojson.Safe.lexer_state -> Lexing.lexbuf -> 'a) ->
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> 'a abs2
  (** Input JSON data of type {!abs2}. *)

val abs2_of_string :
  (Yojson.Safe.lexer_state -> Lexing.lexbuf -> 'a) ->
  string -> 'a abs2
  (** Deserialize JSON data of type {!abs2}. *)


val write_abs1 :
  (Bi_outbuf.t -> 'a -> unit) ->
  Bi_outbuf.t -> 'a abs1 -> unit
  (** Output a JSON value of type {!abs1}. *)

val string_of_abs1 :
  (Bi_outbuf.t -> 'a -> unit) ->
  ?len:int -> 'a abs1 -> string
  (** Serialize a value of type {!abs1}
      into a JSON string.
      @param len specifies the initial length
                 of the buffer used internally.
                 Default: 1024. *)

val read_abs1 :
  (Yojson.Safe.lexer_state -> Lexing.lexbuf -> 'a) ->
  Yojson.Safe.lexer_state -> Lexing.lexbuf -> 'a abs1
  (** Input JSON data of type {!abs1}. *)

val abs1_of_string :
  (Yojson.Safe.lexer_state -> Lexing.lexbuf -> 'a) ->
  string -> 'a abs1
  (** Deserialize JSON data of type {!abs1}. *)


atd-2.1.0/atdgen/test/testv.expected.ml000066400000000000000000000261561357165332000200210ustar00rootroot00000000000000(* Auto-generated from "test.atd" *)
              [@@@ocaml.warning "-27-32-35-39"]

(** This is just a test. *)

type test_variant = Test.test_variant

type ('x, 'y) poly = ('x, 'y) Test.poly = {
  fst: 'x list;
  snd: ('x, 'y) poly option
}

type 'a p' = 'a Test.p' =  A | Bb of 'a p' | Ccccc of 'a 

type p = Test.p

and r = Test.r = { a: int; mutable b: bool; c: p }

type validated_string_check = Test.validated_string_check

type validate_me = Test.validate_me

type val1 = Test.val1 = { val1_x: int }

type val2 = Test.val2 = { val2_x: val1; val2_y: val1 option }

type unixtime_list = Test.unixtime_list

type date = Test.date

type mixed_record = Test.mixed_record = {
  field0: int option;
  field1: float option;
  field2: string option;
  field3: Int64.t;
  field4: float Atdgen_runtime.Util.ocaml_array;
  field5: bool option;
  field6: string option;
  field7: test_variant;
  field8: string Atdgen_runtime.Util.ocaml_array;
  field9: (int * int * Char.t * int * Int32.t * Int64.t);
  field10: bool;
  field11: bool;
  field12: unit list;
  field13: string option list;
  field14: date
}

type mixed = Test.mixed

type test = Test.test = {
  x0: int option;
  x1: float option;
  x2: mixed;
  x3: mixed_record list;
  x4: Int64.t
}

type tup = Test.tup

type star_rating = Test.star_rating

type 'a generic = 'a Test.generic = { x294623: int }

type specialized = Test.specialized

type some_record = Test.some_record = { some_field: int }

type precision = Test.precision = {
  sqrt2_5: float;
  small_2: float;
  large_2: float
}

type p'' = Test.p''

type option_validation = Test.option_validation

type no_real_wrap = Test.no_real_wrap

type natural = Test.natural

type id = Test.id

type json_map = Test.json_map

type intopt = Test.intopt

type int_assoc_list = Test.int_assoc_list

type int_assoc_array = Test.int_assoc_array

type int8 = Test.int8

type int64 = Test.int64

type int32 = Test.int32

type hello = Test.hello

type floats = Test.floats = { f32: float; f64: float }

type extended_tuple = Test.extended_tuple

type extended = Test.extended = {
  b0x (*atd b0 *): int;
  b1x (*atd b1 *): bool;
  b2x (*atd b2 *): string;
  b3x (*atd b3 *): string option;
  b4x (*atd b4 *): string option;
  b5x (*atd b5 *): float
}

type even_natural = Test.even_natural

(**
  \}\}\}abc[def]ghi
  
{v
j  *  j
 k * k
  l*l
v}
  
{v
mno
v}
  
  [pqr]\{stu\}vwx
  
  yz
  
  [\} \[ \] \{v]
  
{v
\} [x] v\} \{v [ @ 
v}
*)
type def = Test.def

type char = Test.char

type base_tuple = Test.base_tuple

type base = Test.base = { b0: int; b1: bool }

type 'a array = 'a Test.array

type 'a abs3 = 'a Test.abs3

type 'a abs2 = 'a Test.abs2

type 'a abs1 = 'a Test.abs1

let validate__19 validate__a = (
  Atdgen_runtime.Ov_run.validate_list (
    validate__a
  )
)
let rec validate_p' validate__a : _ -> 'a p' -> _ = (
  fun path x ->
    match x with
      | A -> None
      | Bb x ->
        (
          validate_p' validate__a
        ) path x
      | Ccccc x ->
        (
          validate__a
        ) path x
)
let rec validate_p = (
  fun path x ->
    match ( fun path x ->
         match x with
           `A -> Some (Atdgen_runtime.Util.Validation.error path)
         | _ -> None ) path x with
      | Some _ as err -> err
      | None ->
        match x with
          | `A -> None
          | `B x ->
            (
              validate_r
            ) path x
          | `C -> None
)
and validate_r : _ -> r -> _ = (
  fun path x ->
    match
      (
        fun _ _ -> None
      ) (`Field "a" :: path) x.a
    with
      | Some _ as err -> err
      | None ->
        (
          validate_p
        ) (`Field "c" :: path) x.c
)
let rec validate__20 validate__a validate__b path x = (
  Atdgen_runtime.Ov_run.validate_option (
    validate_poly validate__a validate__b
  )
) path x
and validate_poly validate__x validate__y : _ -> ('x, 'y) poly -> _ = (
  fun path x ->
    match
      (
        validate__19 validate__x
      ) (`Field "fst" :: path) x.fst
    with
      | Some _ as err -> err
      | None ->
        (
          validate__20 validate__x validate__y
        ) (`Field "snd" :: path) x.snd
)
let rec validate__2 path x = (
  fun _ _ -> None
) path x
and validate_test_variant path x = (
  fun _ _ -> None
) path x
let rec validate__1 path (x : _ p') = (
  fun _ _ -> None
) path x
let validate_validated_string_check = (
  fun path x ->
    let msg = "Failed check by fun s -> s = \"abc\"" in
    if (fun s -> s = "abc") x then
      None
    else
      Some (Atdgen_runtime.Util.Validation.error ~msg path)
)
let validate__31 = (
  (fun path x ->
    (match ( fun path x ->
    let msg = "Failed check by fun l -> true" in
    if (fun l -> true) x then
      None
    else
      Some (Atdgen_runtime.Util.Validation.error ~msg path) ) path x with
      | Some _ as err -> err
      | None -> (
          Atdgen_runtime.Ov_run.validate_list (
            fun path x ->
    let msg = "Failed check by fun s -> true" in
    if (fun s -> true) x then
      None
    else
      Some (Atdgen_runtime.Util.Validation.error ~msg path)
          )
        ) path x
    )
  )
)
let validate_validate_me = (
  validate__31
)
let validate_val1 : _ -> val1 -> _ = (
  fun path x ->
    (
      fun path _ -> Some (Atdgen_runtime.Util.Validation.error path)
    ) (`Field "val1_x" :: path) x.val1_x
)
let validate__16 = (
  Atdgen_runtime.Ov_run.validate_option (
    validate_val1
  )
)
let validate_val2 : _ -> val2 -> _ = (
  fun path x ->
    match
      (
        validate_val1
      ) (`Field "val2_x" :: path) x.val2_x
    with
      | Some _ as err -> err
      | None ->
        (
          validate__16
        ) (`Field "val2_y" :: path) x.val2_y
)
let validate__29 = (
  fun _ _ -> None
)
let validate_unixtime_list = (
  validate__29
)
let validate__3 = (
  fun _ _ -> None
)
let validate_date = (
  fun _ _ -> None
)
let validate__9 = (
  fun _ _ -> None
)
let validate__8 = (
  fun _ _ -> None
)
let validate__7 = (
  fun _ _ -> None
)
let validate__6 = (
  fun _ _ -> None
)
let validate__5 = (
  fun _ _ -> None
)
let validate__4 = (
  fun _ _ -> None
)
let validate__11 = (
  fun _ _ -> None
)
let validate__10 = (
  fun _ _ -> None
)
let validate_mixed_record : _ -> mixed_record -> _ = (
  fun _ _ -> None
)
let validate__13 = (
  fun _ _ -> None
)
let validate__12 = (
  fun _ _ -> None
)
let validate__14 = (
  fun _ _ -> None
)
let validate_mixed = (
  validate__14
)
let validate__15 = (
  fun _ _ -> None
)
let validate_test : _ -> test -> _ = (
  fun _ _ -> None
)
let validate_tup = (
  fun _ _ -> None
)
let validate_star_rating = (
  fun path x ->
    let msg = "Failed check by fun x -> x >= 1 && x <= 5" in
    if (fun x -> x >= 1 && x <= 5) x then
      None
    else
      Some (Atdgen_runtime.Util.Validation.error ~msg path)
)
let validate__30 : _ -> _ generic -> _ = (
  fun _ _ -> None
)
let validate_specialized = (
  validate__30
)
let validate_some_record : _ -> some_record -> _ = (
  fun path x ->
    (
      fun path x -> failwith "passed"
    ) (`Field "some_field" :: path) x.some_field
)
let validate_precision : _ -> precision -> _ = (
  fun _ _ -> None
)
let validate_p'' = (
  validate__1
)
let validate__18 = (
  Atdgen_runtime.Ov_run.validate_option (
    fun path _ -> Some (Atdgen_runtime.Util.Validation.error path)
  )
)
let validate_option_validation = (
  validate__18
)
let validate__28 = (
  validate_some_record
)
let validate_no_real_wrap = (
  validate__28
)
let validate__26 = (
  fun _ _ -> None
)
let validate_natural = (
  validate__26
)
let validate__24 = (
  fun path x ->
                       match x with
                         `Id "" -> failwith "empty"
                       | _ -> None
)
let validate_id = (
  validate__24
)
let validate__25 = (
  Atdgen_runtime.Ov_run.validate_list (
    fun path x ->
      (let x, _ = x in
      (
        validate_id
      ) (`Index 0 :: path) x
      )
  )
)
let validate_json_map = (
  validate__25
)
let validate_intopt = (
  validate__4
)
let validate__21 = (
  fun _ _ -> None
)
let validate_int_assoc_list = (
  validate__21
)
let validate__22 = (
  fun _ _ -> None
)
let validate_int_assoc_array = (
  validate__22
)
let validate_int8 = (
  (fun _ _ -> None)
)
let validate_int64 = (
  (fun _ _ -> None)
)
let validate_int32 = (
  (fun _ _ -> None)
)
let validate_hello = (
  fun _ _ -> None
)
let validate_generic validate__a : _ -> 'a generic -> _ = (
  fun _ _ -> None
)
let validate_floats : _ -> floats -> _ = (
  fun _ _ -> None
)
let validate__17 = (
  fun _ _ -> None
)
let validate_extended_tuple = (
  fun _ _ -> None
)
let validate_extended : _ -> extended -> _ = (
  fun path x ->
    match ( fun path x ->
      if x.b0x >= 0 then None
      else Some (Atdgen_runtime.Util.Validation.error path) ) path x with
      | Some _ as err -> err
      | None ->
        (
          fun path x ->
        if x = false then None else Some (Atdgen_runtime.Util.Validation.error path)
        ) (`Field "b1x" :: path) x.b1x
)
let validate__27 = (
  fun _ _ -> None
)
let validate_even_natural = (
  validate__27
)
let validate_char = (
  (fun _ _ -> None)
)
let validate_base_tuple = (
  fun path (i, f) -> if float i < f then None else Some (Atdgen_runtime.Util.Validation.error ~msg:"i < f" path)
)
let validate_base : _ -> base -> _ = (
  fun _ _ -> None
)
let validate__23 validate__a = (
  Atdgen_runtime.Ov_run.validate_array (
    validate__a
  )
)
let validate_array validate__a = (
  validate__23 validate__a
)
let validate_abs3 validate__a = (
  validate__19 validate__a
)
let validate_abs2 validate__a = (
  validate__19 validate__a
)
let validate_abs1 validate__a = (
  validate__19 validate__a
)
let create_r 
  ~a
  ~b
  ~c
  () : r =
  {
    a = a;
    b = b;
    c = c;
  }
let create_poly 
  ~fst
  ~snd
  () : ('x, 'y) poly =
  {
    fst = fst;
    snd = snd;
  }
let create_val1 
  ~val1_x
  () : val1 =
  {
    val1_x = val1_x;
  }
let create_val2 
  ~val2_x
  ?val2_y
  () : val2 =
  {
    val2_x = val2_x;
    val2_y = val2_y;
  }
let create_mixed_record 
  ?field0
  ?field1
  ~field2
  ~field3
  ~field4
  ?field5
  ?field6
  ~field7
  ~field8
  ~field9
  ~field10
  ?(field11 = false)
  ~field12
  ~field13
  ~field14
  () : mixed_record =
  {
    field0 = field0;
    field1 = field1;
    field2 = field2;
    field3 = field3;
    field4 = field4;
    field5 = field5;
    field6 = field6;
    field7 = field7;
    field8 = field8;
    field9 = field9;
    field10 = field10;
    field11 = field11;
    field12 = field12;
    field13 = field13;
    field14 = field14;
  }
let create_test 
  ?x0
  ?x1
  ~x2
  ~x3
  ~x4
  () : test =
  {
    x0 = x0;
    x1 = x1;
    x2 = x2;
    x3 = x3;
    x4 = x4;
  }
let create_some_record 
  ~some_field
  () : some_record =
  {
    some_field = some_field;
  }
let create_precision 
  ~sqrt2_5
  ~small_2
  ~large_2
  () : precision =
  {
    sqrt2_5 = sqrt2_5;
    small_2 = small_2;
    large_2 = large_2;
  }
let create_generic 
  ~x294623
  () : 'a generic =
  {
    x294623 = x294623;
  }
let create_floats 
  ~f32
  ~f64
  () : floats =
  {
    f32 = f32;
    f64 = f64;
  }
let create_extended 
  ~b0x
  ~b1x
  ~b2x
  ?b3x
  ~b4x
  ?(b5x = 0.5)
  () : extended =
  {
    b0x = b0x;
    b1x = b1x;
    b2x = b2x;
    b3x = b3x;
    b4x = b4x;
    b5x = b5x;
  }
let create_base 
  ~b0
  ~b1
  () : base =
  {
    b0 = b0;
    b1 = b1;
  }
atd-2.1.0/atdgen/test/testv.expected.mli000066400000000000000000000307411357165332000201650ustar00rootroot00000000000000(* Auto-generated from "test.atd" *)
              [@@@ocaml.warning "-27-32-35-39"]

(** This is just a test. *)

type test_variant = Test.test_variant

type ('x, 'y) poly = ('x, 'y) Test.poly = {
  fst: 'x list;
  snd: ('x, 'y) poly option
}

type 'a p' = 'a Test.p' =  A | Bb of 'a p' | Ccccc of 'a 

type p = Test.p

and r = Test.r = { a: int; mutable b: bool; c: p }

type validated_string_check = Test.validated_string_check

type validate_me = Test.validate_me

type val1 = Test.val1 = { val1_x: int }

type val2 = Test.val2 = { val2_x: val1; val2_y: val1 option }

type unixtime_list = Test.unixtime_list

type date = Test.date

type mixed_record = Test.mixed_record = {
  field0: int option;
  field1: float option;
  field2: string option;
  field3: Int64.t;
  field4: float Atdgen_runtime.Util.ocaml_array;
  field5: bool option;
  field6: string option;
  field7: test_variant;
  field8: string Atdgen_runtime.Util.ocaml_array;
  field9: (int * int * Char.t * int * Int32.t * Int64.t);
  field10: bool;
  field11: bool;
  field12: unit list;
  field13: string option list;
  field14: date
}

type mixed = Test.mixed

type test = Test.test = {
  x0: int option;
  x1: float option;
  x2: mixed;
  x3: mixed_record list;
  x4: Int64.t
}

type tup = Test.tup

type star_rating = Test.star_rating

type 'a generic = 'a Test.generic = { x294623: int }

type specialized = Test.specialized

type some_record = Test.some_record = { some_field: int }

type precision = Test.precision = {
  sqrt2_5: float;
  small_2: float;
  large_2: float
}

type p'' = Test.p''

type option_validation = Test.option_validation

type no_real_wrap = Test.no_real_wrap

type natural = Test.natural

type id = Test.id

type json_map = Test.json_map

type intopt = Test.intopt

type int_assoc_list = Test.int_assoc_list

type int_assoc_array = Test.int_assoc_array

type int8 = Test.int8

type int64 = Test.int64

type int32 = Test.int32

type hello = Test.hello

type floats = Test.floats = { f32: float; f64: float }

type extended_tuple = Test.extended_tuple

type extended = Test.extended = {
  b0x (*atd b0 *): int;
  b1x (*atd b1 *): bool;
  b2x (*atd b2 *): string;
  b3x (*atd b3 *): string option;
  b4x (*atd b4 *): string option;
  b5x (*atd b5 *): float
}

type even_natural = Test.even_natural

(**
  \}\}\}abc[def]ghi
  
{v
j  *  j
 k * k
  l*l
v}
  
{v
mno
v}
  
  [pqr]\{stu\}vwx
  
  yz
  
  [\} \[ \] \{v]
  
{v
\} [x] v\} \{v [ @ 
v}
*)
type def = Test.def

type char = Test.char

type base_tuple = Test.base_tuple

type base = Test.base = { b0: int; b1: bool }

type 'a array = 'a Test.array

type 'a abs3 = 'a Test.abs3

type 'a abs2 = 'a Test.abs2

type 'a abs1 = 'a Test.abs1

val validate_test_variant :
  Atdgen_runtime.Util.Validation.path -> test_variant -> Atdgen_runtime.Util.Validation.error option
  (** Validate a value of type {!test_variant}. *)

val create_poly :
  fst: 'x list ->
  snd: ('x, 'y) poly option ->
  unit -> ('x, 'y) poly
  (** Create a record of type {!poly}. *)

val validate_poly :
  (Atdgen_runtime.Util.Validation.path -> 'x -> Atdgen_runtime.Util.Validation.error option) ->
  (Atdgen_runtime.Util.Validation.path -> 'y -> Atdgen_runtime.Util.Validation.error option) ->
  Atdgen_runtime.Util.Validation.path -> ('x, 'y) poly -> Atdgen_runtime.Util.Validation.error option
  (** Validate a value of type {!poly}. *)

val validate_p' :
  (Atdgen_runtime.Util.Validation.path -> 'a -> Atdgen_runtime.Util.Validation.error option) ->
  Atdgen_runtime.Util.Validation.path -> 'a p' -> Atdgen_runtime.Util.Validation.error option
  (** Validate a value of type {!p'}. *)

val validate_p :
  Atdgen_runtime.Util.Validation.path -> p -> Atdgen_runtime.Util.Validation.error option
  (** Validate a value of type {!p}. *)

val create_r :
  a: int ->
  b: bool ->
  c: p ->
  unit -> r
  (** Create a record of type {!r}. *)

val validate_r :
  Atdgen_runtime.Util.Validation.path -> r -> Atdgen_runtime.Util.Validation.error option
  (** Validate a value of type {!r}. *)

val validate_validated_string_check :
  Atdgen_runtime.Util.Validation.path -> validated_string_check -> Atdgen_runtime.Util.Validation.error option
  (** Validate a value of type {!validated_string_check}. *)

val validate_validate_me :
  Atdgen_runtime.Util.Validation.path -> validate_me -> Atdgen_runtime.Util.Validation.error option
  (** Validate a value of type {!validate_me}. *)

val create_val1 :
  val1_x: int ->
  unit -> val1
  (** Create a record of type {!val1}. *)

val validate_val1 :
  Atdgen_runtime.Util.Validation.path -> val1 -> Atdgen_runtime.Util.Validation.error option
  (** Validate a value of type {!val1}. *)

val create_val2 :
  val2_x: val1 ->
  ?val2_y: val1 ->
  unit -> val2
  (** Create a record of type {!val2}. *)

val validate_val2 :
  Atdgen_runtime.Util.Validation.path -> val2 -> Atdgen_runtime.Util.Validation.error option
  (** Validate a value of type {!val2}. *)

val validate_unixtime_list :
  Atdgen_runtime.Util.Validation.path -> unixtime_list -> Atdgen_runtime.Util.Validation.error option
  (** Validate a value of type {!unixtime_list}. *)

val validate_date :
  Atdgen_runtime.Util.Validation.path -> date -> Atdgen_runtime.Util.Validation.error option
  (** Validate a value of type {!date}. *)

val create_mixed_record :
  ?field0: int ->
  ?field1: float ->
  field2: string option ->
  field3: Int64.t ->
  field4: float Atdgen_runtime.Util.ocaml_array ->
  ?field5: bool ->
  ?field6: string ->
  field7: test_variant ->
  field8: string Atdgen_runtime.Util.ocaml_array ->
  field9: (int * int * Char.t * int * Int32.t * Int64.t) ->
  field10: bool ->
  ?field11: bool ->
  field12: unit list ->
  field13: string option list ->
  field14: date ->
  unit -> mixed_record
  (** Create a record of type {!mixed_record}. *)

val validate_mixed_record :
  Atdgen_runtime.Util.Validation.path -> mixed_record -> Atdgen_runtime.Util.Validation.error option
  (** Validate a value of type {!mixed_record}. *)

val validate_mixed :
  Atdgen_runtime.Util.Validation.path -> mixed -> Atdgen_runtime.Util.Validation.error option
  (** Validate a value of type {!mixed}. *)

val create_test :
  ?x0: int ->
  ?x1: float ->
  x2: mixed ->
  x3: mixed_record list ->
  x4: Int64.t ->
  unit -> test
  (** Create a record of type {!test}. *)

val validate_test :
  Atdgen_runtime.Util.Validation.path -> test -> Atdgen_runtime.Util.Validation.error option
  (** Validate a value of type {!test}. *)

val validate_tup :
  Atdgen_runtime.Util.Validation.path -> tup -> Atdgen_runtime.Util.Validation.error option
  (** Validate a value of type {!tup}. *)

val validate_star_rating :
  Atdgen_runtime.Util.Validation.path -> star_rating -> Atdgen_runtime.Util.Validation.error option
  (** Validate a value of type {!star_rating}. *)

val create_generic :
  x294623: int ->
  unit -> 'a generic
  (** Create a record of type {!generic}. *)

val validate_generic :
  (Atdgen_runtime.Util.Validation.path -> 'a -> Atdgen_runtime.Util.Validation.error option) ->
  Atdgen_runtime.Util.Validation.path -> 'a generic -> Atdgen_runtime.Util.Validation.error option
  (** Validate a value of type {!generic}. *)

val validate_specialized :
  Atdgen_runtime.Util.Validation.path -> specialized -> Atdgen_runtime.Util.Validation.error option
  (** Validate a value of type {!specialized}. *)

val create_some_record :
  some_field: int ->
  unit -> some_record
  (** Create a record of type {!some_record}. *)

val validate_some_record :
  Atdgen_runtime.Util.Validation.path -> some_record -> Atdgen_runtime.Util.Validation.error option
  (** Validate a value of type {!some_record}. *)

val create_precision :
  sqrt2_5: float ->
  small_2: float ->
  large_2: float ->
  unit -> precision
  (** Create a record of type {!precision}. *)

val validate_precision :
  Atdgen_runtime.Util.Validation.path -> precision -> Atdgen_runtime.Util.Validation.error option
  (** Validate a value of type {!precision}. *)

val validate_p'' :
  Atdgen_runtime.Util.Validation.path -> p'' -> Atdgen_runtime.Util.Validation.error option
  (** Validate a value of type {!p''}. *)

val validate_option_validation :
  Atdgen_runtime.Util.Validation.path -> option_validation -> Atdgen_runtime.Util.Validation.error option
  (** Validate a value of type {!option_validation}. *)

val validate_no_real_wrap :
  Atdgen_runtime.Util.Validation.path -> no_real_wrap -> Atdgen_runtime.Util.Validation.error option
  (** Validate a value of type {!no_real_wrap}. *)

val validate_natural :
  Atdgen_runtime.Util.Validation.path -> natural -> Atdgen_runtime.Util.Validation.error option
  (** Validate a value of type {!natural}. *)

val validate_id :
  Atdgen_runtime.Util.Validation.path -> id -> Atdgen_runtime.Util.Validation.error option
  (** Validate a value of type {!id}. *)

val validate_json_map :
  Atdgen_runtime.Util.Validation.path -> json_map -> Atdgen_runtime.Util.Validation.error option
  (** Validate a value of type {!json_map}. *)

val validate_intopt :
  Atdgen_runtime.Util.Validation.path -> intopt -> Atdgen_runtime.Util.Validation.error option
  (** Validate a value of type {!intopt}. *)

val validate_int_assoc_list :
  Atdgen_runtime.Util.Validation.path -> int_assoc_list -> Atdgen_runtime.Util.Validation.error option
  (** Validate a value of type {!int_assoc_list}. *)

val validate_int_assoc_array :
  Atdgen_runtime.Util.Validation.path -> int_assoc_array -> Atdgen_runtime.Util.Validation.error option
  (** Validate a value of type {!int_assoc_array}. *)

val validate_int8 :
  Atdgen_runtime.Util.Validation.path -> int8 -> Atdgen_runtime.Util.Validation.error option
  (** Validate a value of type {!int8}. *)

val validate_int64 :
  Atdgen_runtime.Util.Validation.path -> int64 -> Atdgen_runtime.Util.Validation.error option
  (** Validate a value of type {!int64}. *)

val validate_int32 :
  Atdgen_runtime.Util.Validation.path -> int32 -> Atdgen_runtime.Util.Validation.error option
  (** Validate a value of type {!int32}. *)

val validate_hello :
  Atdgen_runtime.Util.Validation.path -> hello -> Atdgen_runtime.Util.Validation.error option
  (** Validate a value of type {!hello}. *)

val create_floats :
  f32: float ->
  f64: float ->
  unit -> floats
  (** Create a record of type {!floats}. *)

val validate_floats :
  Atdgen_runtime.Util.Validation.path -> floats -> Atdgen_runtime.Util.Validation.error option
  (** Validate a value of type {!floats}. *)

val validate_extended_tuple :
  Atdgen_runtime.Util.Validation.path -> extended_tuple -> Atdgen_runtime.Util.Validation.error option
  (** Validate a value of type {!extended_tuple}. *)

val create_extended :
  b0x: int ->
  b1x: bool ->
  b2x: string ->
  ?b3x: string ->
  b4x: string option ->
  ?b5x: float ->
  unit -> extended
  (** Create a record of type {!extended}. *)

val validate_extended :
  Atdgen_runtime.Util.Validation.path -> extended -> Atdgen_runtime.Util.Validation.error option
  (** Validate a value of type {!extended}. *)

val validate_even_natural :
  Atdgen_runtime.Util.Validation.path -> even_natural -> Atdgen_runtime.Util.Validation.error option
  (** Validate a value of type {!even_natural}. *)

val validate_char :
  Atdgen_runtime.Util.Validation.path -> char -> Atdgen_runtime.Util.Validation.error option
  (** Validate a value of type {!char}. *)

val validate_base_tuple :
  Atdgen_runtime.Util.Validation.path -> base_tuple -> Atdgen_runtime.Util.Validation.error option
  (** Validate a value of type {!base_tuple}. *)

val create_base :
  b0: int ->
  b1: bool ->
  unit -> base
  (** Create a record of type {!base}. *)

val validate_base :
  Atdgen_runtime.Util.Validation.path -> base -> Atdgen_runtime.Util.Validation.error option
  (** Validate a value of type {!base}. *)

val validate_array :
  (Atdgen_runtime.Util.Validation.path -> 'a -> Atdgen_runtime.Util.Validation.error option) ->
  Atdgen_runtime.Util.Validation.path -> 'a array -> Atdgen_runtime.Util.Validation.error option
  (** Validate a value of type {!array}. *)

val validate_abs3 :
  (Atdgen_runtime.Util.Validation.path -> 'a -> Atdgen_runtime.Util.Validation.error option) ->
  Atdgen_runtime.Util.Validation.path -> 'a abs3 -> Atdgen_runtime.Util.Validation.error option
  (** Validate a value of type {!abs3}. *)

val validate_abs2 :
  (Atdgen_runtime.Util.Validation.path -> 'a -> Atdgen_runtime.Util.Validation.error option) ->
  Atdgen_runtime.Util.Validation.path -> 'a abs2 -> Atdgen_runtime.Util.Validation.error option
  (** Validate a value of type {!abs2}. *)

val validate_abs1 :
  (Atdgen_runtime.Util.Validation.path -> 'a -> Atdgen_runtime.Util.Validation.error option) ->
  Atdgen_runtime.Util.Validation.path -> 'a abs1 -> Atdgen_runtime.Util.Validation.error option
  (** Validate a value of type {!abs1}. *)

atd-2.1.0/atdgen/util/000077500000000000000000000000001357165332000145065ustar00rootroot00000000000000atd-2.1.0/atdgen/util/recompile-deps000077500000000000000000000010721357165332000173440ustar00rootroot00000000000000# -*- sh -*-
# Script for working with development versions of atdgen's dependencies.
# All git repositories (atd, atdgen, etc.) must exist in the same directory.

# Usage (from within atdgen/): . util/recompile-deps

# This script is meant to be sourced from the atdgen directory.
# It sets the OCAMLPATH variable such that the development versions
# of atdgen's dependencies are found first when compiling.

atdgen_dir=$(pwd)
parent=$atdgen_dir/..
export OCAMLPATH=$parent
for x in cppo easy-format atd biniou yojson atdgen; do
  (cd parent/$x; make clean; make)
done
atd-2.1.0/atdj.opam000066400000000000000000000034211357165332000140670ustar00rootroot00000000000000# This file is generated by dune, edit dune-project instead
opam-version: "2.0"
synopsis: "Java code generation for ATD"
description: """
Atdj is a program that generates a Java interface from type definitions. In
particular, given a set of ATD type definitions, this tool generates a set of
Java classes representing those types with built-in JSON serializers and
deserializers

The primary benefits of using the generated interface, over manually
manipulating JSON strings from within Java, are safety and ease of use.
Specifically, the generated interface offers the following features:

- JSON strings are automatically checked for correctness with respect to the ATD
specification.

- Details such as optional fields and their associated default values are
automatically handled"""
maintainer: ["Rudi Grinberg "]
authors: [
  "Martin Jambon "
  "David Sheets "
  "Rudi Grinberg "
  "Ivan Jager "
  "Jeff Meister "
  "Carmelo Piccione "
  "Raman Varabets "
  "Mathieu Baudet "
  "Rauan Mayemir "
  "Louis Roché "
  "Brendan Long "
  "Christophe Troestler "
  "Vincent Bernardoff "
  "haoyang "
]
license: "MIT"
homepage: "https://github.com/ahrefs/atd"
bug-reports: "https://github.com/ahrefs/atd/issues"
depends: [
  "ocaml" {>= "4.02"}
  "dune" {>= "1.11"}
  "atd" {>= "2.0.0"}
  "re"
]
dev-repo: "git+https://github.com/ahrefs/atd.git"
build: [
  ["dune" "subst"] {pinned}
  [
    "dune"
    "build"
    "-p"
    name
    "-j"
    jobs
    "@install"
    "@doc" {with-doc}
  ]
]
atd-2.1.0/atdj.opam.template000066400000000000000000000002171357165332000157010ustar00rootroot00000000000000build: [
  ["dune" "subst"] {pinned}
  [
    "dune"
    "build"
    "-p"
    name
    "-j"
    jobs
    "@install"
    "@doc" {with-doc}
  ]
]
atd-2.1.0/atdj/000077500000000000000000000000001357165332000132115ustar00rootroot00000000000000atd-2.1.0/atdj/AUTHORS000066400000000000000000000001751357165332000142640ustar00rootroot00000000000000John Billings 
Martin Jambon 
and contributors that can be found in the git history.
atd-2.1.0/atdj/README.md000066400000000000000000000012261357165332000144710ustar00rootroot00000000000000Atdj
====

Atdj is a program that generates a Java interface from type definitions.
In particular, given a set of ATD type definitions,
this tool generates a set of Java classes representing those types
with built-in JSON serializers and deserializers.

The primary benefits of using the generated interface, over manually
manipulating JSON strings from within Java, are safety and ease of use.
Specifically, the generated interface offers the following features:

* JSON strings are automatically checked for correctness with
  respect to the ATD specification.
* Details such as optional fields and their associated default values are
  automatically handled.
atd-2.1.0/atdj/TODO000066400000000000000000000007721357165332000137070ustar00rootroot00000000000000Now:
- update documentation for ArrayList and for variants

Later:
- produce an output tree using Atd.Indent rather fprintf
  (for clarity and atdj performance)
- variant implementation: avoid memory leak by clearing previous field
- translate atd syntax tree first, then generate code instead of doing
  everything in the same pass (for clarity and atdj performance)
- merge into atdgen
- support top-level lists
- add support for lists of lists
- add location information to exceptions (need own parser)
atd-2.1.0/atdj/doc/000077500000000000000000000000001357165332000137565ustar00rootroot00000000000000atd-2.1.0/atdj/doc/OMakefile000066400000000000000000000011611357165332000155340ustar00rootroot00000000000000# No default target.
# `omake pdf' requires pdflatex and builds readme.pdf
# `omake txt' requires hevea and builds readme.txt
# `omake html' requires hevea and builds readme.html

USEPDFLATEX = true
TEXFILES = readme atdj-body

.PHONY: all pdf txt html
all: pdf txt html
pdf: readme.pdf
txt: readme.txt
html: readme.html

readme.txt: $(addsuffix .tex, $(TEXFILES))
	hevea -text readme
	hevea -text readme

readme.html: $(addsuffix .tex, $(TEXFILES))
	hevea readme
	hevea readme

LaTeXDocument(readme, $(TEXFILES))

.PHONY: clean
clean:
	rm -f *.aux *.toc *.log *.out *.haux *.htoc *.fls \
		readme.pdf readme.txt readme.html
atd-2.1.0/atdj/doc/atdj-body.tex000066400000000000000000000230041357165332000163540ustar00rootroot00000000000000% Body of the documentation for atdj.
% This file is used to generate the README file for atdj,
% and also is included as a section within the PSAPI manual.

The ATDJ tool generates a Java interface from an ATD interface.  In particular,
given a set of ATD types, this tool generates a set of Java classes
representing those types.  These classes may then be instantiated from
JSON representations of those same ATD types.

The primary benefits of using the generated interface, over manually
manipulating JSON strings from within Java, are safety and ease of use.
Specifically, the generated interface offers the following features:

\begin{itemize}
\item JSON strings are automatically checked for correctness with
  respect to the ATD specificion.

\item Details such as optional fields and their associated default values are
  automatically handled.

\item Several utility methods are included ``for free''.
  These support equality testing, the visitor pattern and conversion
  back to JSON.
\end{itemize}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\section{Installation}

\begin{enumerate}
\item Install the dependencies: ATD and Atdgen.  These may be
obtained from \url{http://martin.jambon.free.fr/atd-biniou-intro.html}.
Alternatively, they are available as the packages \verb+godi-atd+
and \verb+godi-atdgen+ using the GODI package manager
(\url{http://godi.camlcity.org/godi/index.html}).

\item Having set the appropriate \verb+OCAMLPATH+ (if necessary),
build the ATDJ tool:

\begin{verbatim}
omake atdj
\end{verbatim}
\end{enumerate}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\section{Quick-start}

In this section we briefly describe how to to generate a Java interface from an
example ATD file \texttt{test.atd}.  We then show how to
build and run an
example application \texttt{AtdjTest} that uses the
generated interface.

\begin{enumerate}
\item Generate and compile the interface:

\begin{verbatim}
./atdj -graph -package com.mylife.test test.atd
export CLASSPATH='.:json.jar'
javac com/mylife/test/*.java
\end{verbatim}

\item Compile and run the example, saving the output for later inspection:

\begin{verbatim}
javac AtdjTest.java
java AtdjTest >test.out
\end{verbatim}

\item Optionally, generate Javadoc documentation:

\begin{verbatim}
  javadoc -d doc -public com.mylife.test
\end{verbatim}

The resulting documentation is located in the directory
\texttt{doc}.

\item Optionally, generate a class graph of the generated interface:

\begin{verbatim}
dot -Tpdf test.dot >test.pdf
\end{verbatim}
\end{enumerate}

The output file \texttt{test.pdf} contains a class graph of the
generated Java interface.  The required \texttt{dot} program is part of the
Graphviz graph visualisation package, and may be download from
\url{http://www.graphviz.org/}.

Alternatively, if the source distribution is present, all of the
above steps can be run as \texttt{omake example}.

In the following sections we discuss the individual steps in more detail,
using the example from above.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\section{Generating the interface}

In this section we describe the process of generating a Java interface from an
ATD specification.

A Java interface is generated from an ATD file as

\begin{verbatim}
./atdj -package  
\end{verbatim}

This outputs a set of Java source files.  The \texttt{-package} option
causes the
resulting classes to be members of the specified package, and also to
be located
in the corresponding output directory.  If no package is specified, then the
default package of \texttt{out} is used.

For example, the command

\begin{verbatim}
./atdj -graph -package com.mylife.test test.atd
\end{verbatim}

\begin{sloppypar}
causes the generated files to be members of the package
\texttt{com.mylife.test} and to be located in the directory
\texttt{com/mylife/test}.
\end{sloppypar}

The generated source files reference various members of the included org.json
package.  Therefore, in order to compile the generated files, the
\texttt{org.json}
package must be located within the Java classpath.  Supposing that the
\texttt{org.json}
package is located within the archive \texttt{json.jar} within the
current directory,
it is sufficient to set the classpath as follows:

\begin{verbatim}
export CLASSPATH='json.jar'
\end{verbatim}

Returning to our example, the generated source files may then be compiled as:

\begin{verbatim}
javac com/mylife/test/*.java
\end{verbatim}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\section{Generating Javadoc documentation}

The generated Java code contains embedded Javadoc comments.
These may be extracted to produce Javadoc documentation.
In the case of our example, it is sufficient to run the following command:

\begin{verbatim}
  javadoc -d doc/example -public com.mylife.test
\end{verbatim}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\section{Generating a class graph}

We now discuss the \texttt{-graph} option of ATDJ.  When enabled, this
causes ATDJ to
output a graph of the class hierarchy of the generated code.  The output is
intended to document the generated code, helping users to avoid consulting the
source code.

Continuing with our example, the use of this option results in the
generation of
an additional output file named \texttt{test.dot}.
Assuming that the \texttt{dot}
program is installed, a PDF class graph named
\texttt{test.pdf} can then
created by running the command

\begin{verbatim}
dot -Tpdf test.dot >test.pdf
\end{verbatim}

In the generated class graph,
rectangular and oval nodes correspond to classes
and interfaces, respectively.  Field names are specified in the second line of
retangular (class) nodes.  Solid arcs denote subtyping
(\texttt{implements}/\texttt{extends}),
whilst dashed arcs link fields to their types.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\section{Translation reference}

In this section we informally define how Java types are generated from ATD
types.

\subsection{Bools, ints, floats, string, lists}

\begin{tabular}{ll}
\toprule
ATD type, \tt t & Java type, \tt  \\
\midrule
\tt bool     & \tt boolean \\
\tt int      & \tt int \\
\tt float    & \tt double \\
\tt string   & \tt String \\
\tt t list   & \tt [] \\
\bottomrule
\end{tabular}

\subsection{Options}

Suppose that we have ATD type \texttt{t option}.  Then this is
translated into the following Java reference type:

\begin{verbatim}
public class CNAME implements Atdj {
  // Constructor
  public CNAME(String s) throws JSONException { ... }

// Get the optional value, if present
public CNAME get() throws JSONException     { ... }

// Comparison and equality
public int     compareTo(CNAME that)        { ... }
public boolean equals(CNAME that)           { ... }

public  value;           // The value
public boolean is_set;      // Whether the value is set
}
\end{verbatim}

\subsection{Records}

Suppose that we have the ATD record type

\begin{verbatim}
{ f_1: t_1
;  ...
; f_n: t_n
}
\end{verbatim}

Then this is translated into the following Java reference type:

\begin{verbatim}
public class CNAME implements Atdj {
  // Constructor
  public CNAME(String s) throws JSONException { ... }

// Comparison and equality
public int     compareTo(CNAME that)        { ... }
public boolean equals(CNAME that)           { ... }

// The individual fields
public  f_1;
...
public  f_n;
}
\end{verbatim}

An optional field \texttt{\~{}f\_i: t\_i} causes the class field
\texttt{f\_i} to be given a default
value of type \texttt{} if the field is absent from the JSON
string used to instantiate the class.  The default values are as follows:

\begin{tabular}{ll}
\toprule
ATD type & Default Java value \\
\midrule
\tt bool     & \tt false \\
\tt int      & \tt 0 \\
\tt float    & \tt 0.0 \\
\tt string   & \tt "" \\
\tt t list   & Empty array \\
\tt t option & Optional value with \tt is\_set = false \\
\bottomrule
\end{tabular}

Default values cannot be defined for record and sum types.

An optional field \texttt{?f\_i: t\_i option} has the same default
behaviour as above,
with the additional behaviour that if the field is present in the JSON string
then the value must be of type  (not  option); the value is then
automatically lifted into a  option, with is\_set = true.

\subsection{Sums}

Suppose that we have the ATD sum type

\begin{verbatim}
[ C_1 of t_1
| ...
| C_n of t_n
]
\end{verbatim}

Then this is translated into the following Java reference types:

\begin{verbatim}
public interface IFCNAME extends Atdj {
  public int     compareTo(IFCNAME that);
  public boolean equals(IFCNAME that);
  ...
}
\end{verbatim}

\begin{verbatim}
public class CNAME_i implements IFCNAME, Atdj {
  // Comparison and equality
  public int     compareTo(CNAME that)        { ... }
  public boolean equals(CNAME that)           { ... }

public  value;
}
\end{verbatim}

The value field is absent if the constructor C\_i has no argument.

\subsection{The Atdj and Visitor interfaces}

All generated reference types additionally implement the interface

\begin{verbatim}
interface Atdj {
  String toString();
  String toString(int indent);
  int hashCode();
  Visitor accept(Visitor v);
}
\end{verbatim}

where the Visitor interface is defined as

\begin{verbatim}
public interface Visitor {
  public void visit(CNAME_1 value);
  ...
  public void visit(CNAME_n value);
}
\end{verbatim}

for generated reference types \texttt{CNAME}\_i.  Visit methods for primitive
and optional primitive types are omitted.
atd-2.1.0/atdj/doc/readme.tex000066400000000000000000000013371357165332000157410ustar00rootroot00000000000000\documentclass[letterpaper,10pt]{article}

\usepackage{ae}
\usepackage{hyperref}
\usepackage{hevea}

\usepackage{verbatim}
\usepackage{alltt}

\usepackage[latin1]{inputenc} 
\usepackage[T1]{fontenc}
\usepackage{url}

\usepackage{booktabs}

\title{ATD for Java (ATDJ)}
%\author{John Doe}
%\date{October 19, 2072}
\pagestyle{headings}

% We suppress indentation at the beginning of each paragraph because paragraphs
% are short and indentation is used heavily for bullet points and code examples
\setlength{\parindent}{0mm}
\setlength{\parskip}{2mm}

% Thickness of top and bottom lines of tables (\toprule, \bottomrule)
\setlength{\heavyrulewidth}{1.5pt}

\begin{document}
\maketitle
\tableofcontents
\include{atdj-body}
\end{document}
atd-2.1.0/atdj/src/000077500000000000000000000000001357165332000140005ustar00rootroot00000000000000atd-2.1.0/atdj/src/atdj_env.ml000066400000000000000000000010041357165332000161170ustar00rootroot00000000000000(* Translation environment *)

type id = string
type ty_name = string

(* Java types *)
type ty =
  [ `Class of ty_name * (id * ty_name) list
      (* Class name and constructor parameters *)
  | `Interface of ty_name
      (* Interface name *)
  ]

type env_t = {
  module_items : (string * Atd.Ast.type_expr) list;
  package      : string;
  package_dir  : string;
  input_file   : string option;
}

let default_env = {
  module_items = [];
  package      = "out";
  package_dir  = "out";
  input_file   = None;
}
atd-2.1.0/atdj/src/atdj_helper.ml000066400000000000000000000074641357165332000166260ustar00rootroot00000000000000(* Helper classes *)

open Atd.Import
open Atdj_env

let output_atdj env =
  let out = Atdj_trans.open_class env "Atdj" in
  fprintf out "\
/**
 * Common utility interface.
 */
public interface Atdj {
  /**
   * Get the JSON string representation, failing if some of the data
   * was not initialized.
   * @return The JSON string.
   */
  String toJson() throws JSONException;

  /**
   * Write the JSON representation to a buffer, failing if some of the data
   * was not initialized.
   */
  void toJsonBuffer(StringBuilder out) throws JSONException;
}
";
  close_out out

let output_util env =
  let out = Atdj_trans.open_class env "Util" in
  fprintf out "\
class Util {
  // Extract the tag of sum-typed value
  static String extractTag(Object value) throws JSONException {
    if (value instanceof String)
      return (String)value;
    else if (value instanceof JSONArray)
      return ((JSONArray)value).getString(0);
    else throw new JSONException(\"Cannot extract type\");
  }

  // Is an option value a none?
  static boolean isNone(Object value) throws JSONException {
    return (value instanceof String) && (((String)value).equals(\"None\"));
  }

  // Is an option value a Some?
  static boolean isSome(Object value) throws JSONException {
    return (value instanceof JSONArray)
      && ((JSONArray)value).getString(0).equals(\"Some\");
  }

  /*
    Encode a JSON string into a buffer
   */
  static void writeJsonString(StringBuilder out, String s) {
    out.append(\"\\\"\");
    for (int i = 0; i < s.length(); ++i) {
      char c = s.charAt(i);
      switch (c) {
      case '\\b':
        out.append(\"\\\\b\");
        break;
      case '\\f':
        out.append(\"\\\\f\");
        break;
      case '\\n':
        out.append(\"\\\\n\");
        break;
      case '\\r':
        out.append(\"\\\\r\");
        break;
      case '\\t':
        out.append(\"\\\\t\");
        break;
      case '\\\\':
        out.append(\"\\\\\\\\\");
        break;
      case '\"':
        out.append(\"\\\\\\\"\");
        break;
      default:
        if (c < 32 || c == 127)
          out.append(String.format(\"\\\\u%%04x\", (int) c));
        else
          out.append(c);
      }
    }
    out.append(\"\\\"\");
  }

  static String jsonStringOfString(String s) {
    StringBuilder out = new StringBuilder();
    writeJsonString(out, s);
    return out.toString();
  }

  // Unescape escaped backslashes and double quotations.
  // All other escape sequences are considered invalid
  // (this is probably too strict).
  static String unescapeString(String str) throws JSONException {
    StringBuilder buf = new StringBuilder();
    for (int i = 0; i < str.length(); ++i) {
      if (str.charAt(i) == '\\\\') {
        if (i == str.length() - 1 ||
            (str.charAt(i + 1) != '\\\\' && str.charAt(i + 1) != '\"'))
          throw new JSONException(\"Invalid escape\");
        else {
          buf.append(str.charAt(i + 1));
          ++i;
        }
      } else {
        buf.append(str.charAt(i));
      }
    }
    return buf.toString();
  }
}
";
  close_out out

let output_package_javadoc env (loc, annots) =
  let out = open_out (env.package_dir ^ "/" ^ "package.html") in
  output_string out "\n";
  let from_doc_para =
    List.fold_left (fun acc -> function
      | Atd.Doc.Text text -> text :: acc
      | Code _ -> failwith "Not yet implemented: code in javadoc comments"
    ) in
  let from_doc =
    List.fold_left (fun acc -> function
      | Atd.Doc.Paragraph para -> from_doc_para acc para
      | Pre _ ->
          failwith "Not yet implemented: \
                    preformatted text in javadoc comments"
    ) [] in
  (match Atd.Doc.get_doc loc annots with
   | Some doc ->
       let str = String.concat "\n
,  and 
.
            This is suitable input for "caml2html -ext html:cat"
            which converts ATD files into HTML.
    -strip NAME1[,NAME2,...]
            remove all annotations of the form ,
            , etc.
    -strip-all 
            remove all annotations
    -version 
            print the version of atd and exit
    -help  Display this list of options
    --help  Display this list of options

ATD language
============

This is a precise description of the syntax of the ATD language, not a
tutorial.

Notations
----------

Lexical and grammatical rules are expressed using a BNF-like syntax.
Graphical terminal symbols use `unquoted strings in typewriter font`.
Non-graphical characters use their official uppercase ASCII name such
as LF for the newline character or SPACE for the space character.
Non-terminal symbols use the regular font and link to their
definition.  Parentheses are used for grouping.

The following postfix operators are used to specify repeats:

------ ---------------------------------
x*     0, 1 or more occurrences of x
x?     0 or 1 occurrence of x
x+     1 or more occurrences of x
------ ---------------------------------


Lexical rules
-------------

ATD does not enforce a particular character encoding other than ASCII
compatibility. Non-ASCII text and data found in annotations and
in comments may contain arbitrary bytes in the non-ASCII range 128-255
without escaping. The UTF-8 encoding is however strongly recommended
for all text. The use of hexadecimal or decimal escape sequences is
recommended for binary data.

An ATD lexer splits its input into a stream of tokens,
discarding whitespace and comments.

---------------- ---------------------------------------- --------------------
       token ::= keyword

               | lident

               | uident

               | tident

               | string

   ignorable ::= space                                    _discarded_

               | comment

       space ::= SPACE | TAB | CR | LF

       blank ::= SPACE | TAB

     comment ::= `(*` (comment | string | byte)* `*)`

      lident ::= (lower | `_` identchar) identchar*       _lowercase
                                                          identifier_

      uident ::= upper identchar*                         _uppercase
                                                          identifier_

      tident ::= `'` lident                               _type parameter_

       lower ::= `a`...`z`

       upper ::= `A`...`Z`

   identchar ::= upper | lower | digit | `_` | `'`

      string ::= `"` substring* `"`                       _string literal,
                                                          used in annotations_

   substring ::= `\\`                                     _single backslash_

               | `\"`                                     _double quote_

               | `\x` hex hex                             _single byte
                                                          in hexadecimal
                                                          notation_

               | `\` digit digit digit                    _single byte
                                                          in decimal
                                                          notation_

               | `\n`                                     _LF_

               | `\r`                                     _CR_

               | `\t`                                     _TAB_

               | `\b`                                     _BS_

               | `\` CR? LF blank*                        _discarded_

               | not-backslash                            _any byte
                                                          except `\`
                                                          or `"`_

       digit ::= `0`...`9`

         hex ::= `0`...`9` | `a`...`f` | `A`...`F`

     keyword ::= `(` | `)` | `[`                          _all keywords_
                 | `]` | \str{\{} | `\`}
                 | `<` | `>` &
                 | `;` | `,` | `:` | `*`
                 | `|` | `=` | `?` | `~`
                 | `type` | `of` | `inherit`
---------------- ---------------------------------------- --------------------


Grammar
-------

---------------- ---------------------------------------- --------------------
      module ::= annot* typedef*                          _entry point_

       annot ::= `<` lident annot-field* `>`              _annotation_

 annot-field ::= (lident (`=` string)?)

     typedef ::= `type` params? lident annot              _type definition_
                 `=` expr

      params ::= tident                                   _one parameter_

               | `(` tident (`,` tident)+ `)`             _two or more
                                                          parameters_

        expr ::= expr-body annot*                         _type expression_

               | tident

   expr-body ::= args? lident

               | `(`                                      _tuple type_
                 (cell (`*` cell)*)?
                 `)`

               | `{`                                      _record type_
                 ((field (`;` field)*) `;`?)?
                 `}`

               | `[`                                      _sum type_
                 (`|`? variant (`|` variant)*)?
                 `]`

        args ::= expr                                     _one argument_

               | `(` expr (`,` expr)+ `)`                 _two or more
                                                          arguments_

        cell ::= (annot+ `:`)? expr

       field ::= (`?` | `~`)? lident `=` expr

               | `inherit` expr

     variant ::= uident annot* `of` expr

               | uident annot*

               | `inherit` expr
------------------------------------------------------------------------------



Predefined type names
---------------------

The following types are considered predefined and may not be
redefined.

------------------------------------------------------------------------------
Type name          Intended use
------------------ -----------------------------------------------------------
`unit`             Type of just one value, useful with parametrized types

`bool`             Boolean

`int`              Integer

`float`            Floating-point number

`string`           Sequence of bytes or characters

`'a option`        Container of zero or one element of type `'a`.
                   See also `'a nullable`.

`'a list`          Collection or sequence of elements of type `'a`

`'a nullable`      Extend type `'a` with an extra conventional value,
                   typically called "null". The operation is idempotent,
                   i.e. `'a nullable` is equivalent to
                   `'a nullable nullable`.

`'a shared`        Values of type `'a` for which sharing must be preserved

`'a wrap`          Values on which a custom, reversible transformation
                   may be applied, as specified by
                   language-specific annotations.

`abstract`         Type defined elsewhere
------------------------------------------------------------------------------


Shared values
-------------

ATD supports a special type $x$ `shared` where $x$ can be
any monomorphic type expression.
It allows notably to represent cyclic values and to enforce that cycles
are preserved during transformations such as serialization.

.. code-block:: ocaml

  (* Example of a simple graph type *)
  type shared_node = node shared (* sharing point *)
  type graph = shared_node list
  type node = {
    label : string;
    neighbors : shared_node list;
  }

Two shared values that are physically identical must remain physically
identical after any translation from one data format to another.

Each occurrence of a `shared` type expression in the ATD
source definition defines its own sharing point.
Therefore the following attempt at defining a graph type will not
preserve cycles because two sharing points are defined:

.. code-block:: ocaml

  (* Incorrect definition of a graph type *)
  type node = {
    label : string;
    neighbors : node shared (* sharing point 1 *) list;
  }

  (* Second occurrence of "shared", won't preserve cycles! *)
  type graph = node shared (* sharing point 2 *) list

There is actually a way of having multiple ``shared`` type expressions using the
same sharing point but this feature is designed for code generators and should
not be used in handwritten ATD definitions. The technique consists in providing
an annotation of the form ```` where _x_ is any string
identifying the sharing point. The graph example can be rewritten correctly as:

.. code-block:: ocaml

  type node = {
    label : string;
    neighbors : node shared  list;
  }

  type graph = node shared  list

See also
========
`atdgen`_\ (1)

.. _atdgen: atdgen
atd-2.1.0/doc/tutorial-data/000077500000000000000000000000001357165332000156065ustar00rootroot00000000000000atd-2.1.0/doc/tutorial-data/Makefile000066400000000000000000000001451357165332000172460ustar00rootroot00000000000000.PHONY: clean
clean:
	rm -f */*~
	rm -f */*.cm[ioxa] */*.cmx[as] */*.[oa] */*_[tjv].mli */*_[tjv].ml
atd-2.1.0/doc/tutorial-data/config-file/000077500000000000000000000000001357165332000177705ustar00rootroot00000000000000atd-2.1.0/doc/tutorial-data/config-file/bad-config1.json000066400000000000000000000002631357165332000227360ustar00rootroot00000000000000{
  "title": "Example",
  "credentials": [
    {
      "name": 0,
      "key": "db7c0877bdef3016"
    },
    {
      "name": "tester",
      "key": "09871ff387ac2b10"
    }
  ]
}
atd-2.1.0/doc/tutorial-data/config-file/bad-config2.json000066400000000000000000000003141357165332000227340ustar00rootroot00000000000000{
  "title": "Example",
  "tiemout": 20,
  "credentials": [
    {
      "name": "joeuser",
      "key": "db7c0877bdef3016"
    },
    {
      "name": "tester",
      "key": "09871ff387ac2b10"
    }
  ]
}
atd-2.1.0/doc/tutorial-data/config-file/config.atd000066400000000000000000000005611357165332000217310ustar00rootroot00000000000000type config = {
  title : string;
  ?description : string option;
  ~timeout  : int;
  ~credentials : param list
    ;
}

type param = {
  name : string
    ;
  key : string
    ;
}
atd-2.1.0/doc/tutorial-data/config-file/config.ml000066400000000000000000000054321357165332000215730ustar00rootroot00000000000000open Printf

let param_template =
  (* Sample item used to populate the template config file *)
  {
    Config_v.name = "foo";
    key = "0123456789abcdef"
  }

let config_template =
  (*
    Records can be conveniently created using functions generated by
    "atdgen -v".
    Here we use Config_v.create_config to create a record of type
    Config_t.config. The big advantage over creating the record 
    directly using the record notation {...} is that we don't have to
    specify default values (such as timeout in this example).
  *)
  Config_v.create_config ~title:"" ~credentials: [param_template] ()

let make_json_template () =
  (* Thanks to the -j-defaults flag passed to atdgen, even default
     fields will be printed out *)
  let compact_json = Config_j.string_of_config config_template in
  Yojson.Safe.prettify compact_json

let print_template () =
  print_endline (make_json_template ())

let print_format () =
  print_string Config_atd.contents

let validate fname =
  let x =
    try
      (* Read config data structure from JSON file *)
      let x = Atdgen_runtime.Util.Json.from_file Config_j.read_config fname in
      (* Call the validators specified by  *)
      if not (Config_v.validate_config x) then
        failwith "Some fields are invalid"
      else
        x
    with e ->
      (* Print decent error message and exit *)
      let msg =
        match e with
            Failure s
          | Yojson.Json_error s -> s
          | e -> Printexc.to_string e
      in
      eprintf "Error: %s\n%!" msg;
      exit 1
  in
  (* Convert config to compact JSON and pretty-print it.
     ~std:true means that the output will not use extended syntax for
     variants and tuples but only standard JSON. *)
  let json = Yojson.Safe.prettify ~std:true (Config_j.string_of_config x) in
  print_endline json

type action = Template | Format | Validate of string

let main () =
  let action = ref Template in
  let options = [
    "-template", Arg.Unit (fun () -> action := Template),
    "
          prints a sample configuration file";

    "-format", Arg.Unit (fun () -> action := Format),
    "
          prints the format specification of the config files (atd format)";

    "-validate", Arg.String (fun s -> action := Validate s),
    "
          reads a config file, validates it, adds default values
          and prints the config nicely to stdout";
  ]
  in
  let usage_msg = sprintf "\
Usage: %s [-template|-format|-validate ...]
Demonstration of how to manage JSON configuration files with atdgen.
"
    Sys.argv.(0)
  in
  let anon_fun s = eprintf "Invalid command parameter %S\n%!" s; exit 1 in
  Arg.parse options anon_fun usage_msg;

  match !action with
      Template -> print_template ()
    | Format -> print_format ()
    | Validate s -> validate s

let () = main ()
atd-2.1.0/doc/tutorial-data/config-file/demo.sh000077500000000000000000000017641357165332000212630ustar00rootroot00000000000000#! /bin/sh -e

set -x

# Embed the contents of the .atd file into our OCaml program
echo 'let contents = "\' > config_atd.ml
sed -e 's/\([\\"]\)/\\\1/g' config.atd >> config_atd.ml
echo '"' >> config_atd.ml

# Derive OCaml type definitions from .atd file
atdgen -t config.atd

# Derive JSON-related functions from .atd file
atdgen -j -j-defaults -j-strict-fields config.atd

# Derive validator from .atd file
atdgen -v config.atd

# Compile the OCaml program
ocamlfind ocamlopt -o config \
  config_t.mli config_t.ml config_j.mli config_j.ml config_v.mli config_v.ml \
  config_atd.ml config.ml -package atdgen -linkpkg

# Output a sample config
./config -template

# Print the original type definitions
./config -format

# Fail to validate an invalid config file
./config -validate bad-config1.json || :

# Fail to validate another invalid config file (using custom validators)
./config -validate bad-config3.json || :

# Validate, inject missing defaults and pretty-print
./config -validate sample-config.json
atd-2.1.0/doc/tutorial-data/config-file/sample-config.json000066400000000000000000000002731357165332000234110ustar00rootroot00000000000000{
  "title": "Example",
  "credentials": [
    {
      "name": "joeuser",
      "key": "db7c0877bdef3016"
    },
    {
      "name": "tester",
      "key": "09871ff387ac2b10"
    }
  ]
}
atd-2.1.0/doc/tutorial-data/hello/000077500000000000000000000000001357165332000167115ustar00rootroot00000000000000atd-2.1.0/doc/tutorial-data/hello/demo.sh000077500000000000000000000006431357165332000201770ustar00rootroot00000000000000#! /bin/sh -e

set -x
cat hello.atd
atdgen -t hello.atd
atdgen -j hello.atd
ls
ocamlfind ocamlc -c hello_t.mli -package atdgen
ocamlfind ocamlc -c hello_j.mli -package atdgen
ocamlfind ocamlopt -c hello_t.ml -package atdgen
ocamlfind ocamlopt -c hello_j.ml -package atdgen
ocamlfind ocamlopt -c hello.ml -package atdgen
ocamlfind ocamlopt -o hello hello_t.cmx hello_j.cmx hello.cmx \
  -package atdgen -linkpkg
./hello
atd-2.1.0/doc/tutorial-data/hello/hello.atd000066400000000000000000000000721357165332000205050ustar00rootroot00000000000000type date = {
  year : int;
  month : int;
  day : int;
}
atd-2.1.0/doc/tutorial-data/hello/hello.ml000066400000000000000000000001701357165332000203440ustar00rootroot00000000000000open Hello_t
let () =
  let date = { year = 1970; month = 1; day = 1 } in
  print_endline (Hello_j.string_of_date date)
atd-2.1.0/doc/tutorial-data/inspect-biniou/000077500000000000000000000000001357165332000205365ustar00rootroot00000000000000atd-2.1.0/doc/tutorial-data/inspect-biniou/demo.sh000077500000000000000000000004271357165332000220240ustar00rootroot00000000000000#! /bin/sh -e

set -x

cat tree.atd
cat tree.ml

atdgen -t tree.atd
atdgen -b tree.atd
ocamlfind ocamlopt -o tree \
  tree_t.mli tree_t.ml tree_b.mli tree_b.ml tree.ml \
  -package atdgen -linkpkg
./tree

ls -l tree.dat
bdump tree.dat
bdump -w Empty,Node tree.dat
bdump tree.dat
atd-2.1.0/doc/tutorial-data/inspect-biniou/tree.atd000066400000000000000000000002061357165332000221650ustar00rootroot00000000000000(* This a binary tree. Just for the purpose of pretty-printing trees. *)
type tree =
    [ Empty
    | Node of (tree * int * tree) ]

atd-2.1.0/doc/tutorial-data/inspect-biniou/tree.ml000066400000000000000000000013761357165332000220360ustar00rootroot00000000000000open Printf

(* sample value *)
let tree : Tree_t.tree =
  `Node (
    `Node (`Empty, 1, `Empty),
    2,
    `Node (
      `Node (`Empty, 3, `Empty),
      4,
      `Node (`Empty, 5, `Empty)
    )
  )

let () =
  (* write sample value to file *)
  let fname = "tree.dat" in
  Atdgen_runtime.Util.Biniou.to_file Tree_b.write_tree fname tree;

  (* write sample value to string *)
  let s = Tree_b.string_of_tree tree in
  printf "raw value (saved as %s):\n%S\n" fname s;
  printf "length: %i\n" (String.length s);

  printf "pretty-printed value (without dictionary):\n";
  print_endline (Bi_io.view s);

  printf "pretty-printed value (with dictionary):\n";
  let unhash = Bi_io.make_unhash ["Empty"; "Node"; "foo"; "bar" ] in
  print_endline (Bi_io.view ~unhash s)
atd-2.1.0/doc/tutorial-data/modularity/000077500000000000000000000000001357165332000177775ustar00rootroot00000000000000atd-2.1.0/doc/tutorial-data/modularity/demo.sh000077500000000000000000000011011357165332000212530ustar00rootroot00000000000000#! /bin/sh -e

set -x
cat part1.atd
cat part2.atd
cat part3.atd
for x in part1 part2 part3; do
    atdgen -t $x.atd
    atdgen -j $x.atd
    ocamlfind ocamlc -c ${x}_t.mli -package atdgen
    ocamlfind ocamlc -c ${x}_j.mli -package atdgen
    ocamlfind ocamlopt -c ${x}_t.ml -package atdgen
    ocamlfind ocamlopt -c ${x}_j.ml -package atdgen
done
ocamlfind ocamlopt -c main.ml -package atdgen

ocamlfind ocamlopt -o test_modularity \
  part1_t.cmx part1_j.cmx \
  part2_t.cmx part2_j.cmx \
  part3_t.cmx part3_j.cmx \
  main.cmx \
  -package atdgen -linkpkg
./test_modularity
atd-2.1.0/doc/tutorial-data/modularity/main.ml000066400000000000000000000003221357165332000212520ustar00rootroot00000000000000let v = {
  Part3_t.name = "foo";
  data = Some [
    { Part1_t.x = 1; y = 2 };
    { Part1_t.x = 3; y = 4 };
  ]
}

let () =
  Atdgen_runtime.Util.Json.to_channel Part3_j.write_t3 stdout v;
  print_newline ()
atd-2.1.0/doc/tutorial-data/modularity/part1.atd000066400000000000000000000000361357165332000215170ustar00rootroot00000000000000type t = { x : int; y : int }
atd-2.1.0/doc/tutorial-data/modularity/part2.atd000066400000000000000000000004221357165332000215170ustar00rootroot00000000000000type t1  = abstract
    (*
      Imports type t defined in file part1.atd.
      The local name is t1. Because the local name (t1) is different from the
      original name (t), we must specify the original name using t=.
    *)

type t2 = t1 list
atd-2.1.0/doc/tutorial-data/modularity/part3.atd000066400000000000000000000001351357165332000215210ustar00rootroot00000000000000type t2  = abstract

type t3 = {
  name : string;
  ?data : t2 option;
}
atd-2.1.0/doc/tutorial-data/pretty-json/000077500000000000000000000000001357165332000201045ustar00rootroot00000000000000atd-2.1.0/doc/tutorial-data/pretty-json/demo.sh000077500000000000000000000002751357165332000213730ustar00rootroot00000000000000#! /bin/sh -e

set -x
cat single.json
ydump single.json
cat stream.json
ydump -s stream.json

cat prettify.ml
ocamlfind ocamlopt -o prettify prettify.ml -package atdgen -linkpkg
./prettify
atd-2.1.0/doc/tutorial-data/pretty-json/prettify.ml000066400000000000000000000002761357165332000223110ustar00rootroot00000000000000let json =
"[1234,\"abcde\",{\"start_date\":{\"year\":1970,\"month\":1,\"day\":1}, 
\"end_date\":{\"year\":1980,\"month\":1,\"day\":1}}]"

let () = print_endline (Yojson.Safe.prettify json)
atd-2.1.0/doc/tutorial-data/pretty-json/single.json000066400000000000000000000001531357165332000222570ustar00rootroot00000000000000[1234,"abcde",{"start_date":{"year":1970,"month":1,"day":1}, 
"end_date":{"year":1980,"month":1,"day":1}}]
atd-2.1.0/doc/tutorial-data/pretty-json/stream.json000066400000000000000000000001661357165332000222750ustar00rootroot00000000000000[1234,"abcde",{"start_date":{"year":1970,"month":1,"day":1}, 
"end_date":{"year":1980,"month":1,"day":1}}]
[1,"a",{}]
atd-2.1.0/doc/tutorial-data/untypable-json/000077500000000000000000000000001357165332000205605ustar00rootroot00000000000000atd-2.1.0/doc/tutorial-data/untypable-json/input.json000066400000000000000000000004551357165332000226160ustar00rootroot00000000000000[
  {
    "label": "flower",
    "value": {
      "petals": [12, 45, 83.5555],
      "water": "a340bcf02e"
    }
  },
  {
    "label": "flower",
    "value": {
      "petals": "undefined",
      "fold": null,
      "water": 0
    }
  },
  { "labels": ["fork", "scissors"],
    "value": [ 8, 8 ]
  }
]
atd-2.1.0/doc/tutorial-data/untypable-json/untypable.atd000077700000000000000000000000001357165332000263542untypable_v2.atdustar00rootroot00000000000000atd-2.1.0/doc/tutorial-data/untypable-json/untypable_v1.atd000066400000000000000000000004531357165332000236650ustar00rootroot00000000000000(* File untypable.atd *)

type json  = abstract
  (* uses type Yojson.Safe.t,
     with the functions Yojson.Safe.write_json
     and Yojson.Safe.read_json *)

type obj_list = obj list

type obj = {
  ?label: string option;
  ?labels: string list option;
  value: json
}
atd-2.1.0/doc/tutorial-data/untypable-json/untypable_v2.atd000066400000000000000000000004421357165332000236640ustar00rootroot00000000000000type raw_json  = abstract
  (* uses type Yojson.Safe.t,
     with the functions Yojson.Safe.write_json
     and Yojson.Safe.read_json *)

type obj_list = obj list

type obj = {
  ?label: string option;
  ?labels: string list option;
  value: raw_json
}
atd-2.1.0/doc/tutorial-data/validate/000077500000000000000000000000001357165332000173775ustar00rootroot00000000000000atd-2.1.0/doc/tutorial-data/validate/demo.sh000077500000000000000000000012101357165332000206540ustar00rootroot00000000000000#! /bin/sh -e

set -x
cat resume.atd
atdgen -t resume.atd
atdgen -j resume.atd
atdgen -v resume.atd
ls
ocamlfind ocamlc -c resume_t.mli -package atdgen
ocamlfind ocamlc -c resume_v.mli -package atdgen
ocamlfind ocamlc -c resume_j.mli -package atdgen
ocamlfind ocamlopt -c resume_t.ml -package atdgen
ocamlfind ocamlopt -c resume_util.ml -package atdgen
ocamlfind ocamlopt -c resume_v.ml -package atdgen
ocamlfind ocamlopt -c resume_j.ml -package atdgen
ocamlfind ocamlopt -c resume.ml -package atdgen
ocamlfind ocamlopt -o test_resume \
  resume_t.cmx resume_util.cmx resume_v.cmx resume_j.cmx resume.cmx \
  -package atdgen -linkpkg
./test_resume
atd-2.1.0/doc/tutorial-data/validate/resume.atd000066400000000000000000000005231357165332000213710ustar00rootroot00000000000000type text = string 

type date = {
  year : int;
  month : int;
  day : int;
} 

type job = {
  company : text;
  title : text;
  start_date : date;
  ?end_date : date option;
} 

type work_experience = job list
atd-2.1.0/doc/tutorial-data/validate/resume.ml000066400000000000000000000020751357165332000212350ustar00rootroot00000000000000let check_experience x =
  let is_valid = match Resume_v.validate_work_experience [] x with
    | None -> false
    | _ -> true
  in
  Printf.printf "%s:\n%s\n"
    (if is_valid then "VALID" else "INVALID")
    (Yojson.Safe.prettify (Resume_j.string_of_work_experience x))

let () =
  (* one valid date *)
  let valid = { Resume_t.year = 2000; month = 2; day = 29 } in
  (* one invalid date *)
  let invalid = { Resume_t.year = 2010; month = 0; day = 0 } in
  (* two more valid dates, created with Resume_v.create_date *)
  let date1 = { Resume_t.year = 2005; month = 8; day = 1 } in
  let date2 = { Resume_t.year = 2006; month = 3; day = 22 } in

  let job = {
    Resume_t.company = "Acme Corp.";
    title = "Tester";
    start_date = date1;
    end_date = Some date2;
  }
  in
  let valid_job = { job with Resume_t.start_date = valid } in
  let invalid_job = { job with Resume_t.end_date = Some invalid } in
  let valid_experience = [ job; valid_job ] in
  let invalid_experience = [ job; invalid_job ] in
  check_experience valid_experience;
  check_experience invalid_experience
atd-2.1.0/doc/tutorial-data/validate/resume_util.ml000066400000000000000000000023261357165332000222710ustar00rootroot00000000000000open Resume_t

let ascii_printable c =
  let n = Char.code c in
  n >= 32 && n <= 127

(*
  Check that string is not empty and contains only ASCII printable
  characters (for the sake of the example; we use UTF-8 these days)
*)
let validate_some_text s =
  s <> "" &&
    try
      String.iter (fun c -> if not (ascii_printable c) then raise Exit) s;
      true
    with Exit ->
      false

(*
  Check that the combination of year, month and day exists in the
  Gregorian calendar.
*)
let validate_date x =
  let y = x.year in
  let m = x.month in
  let d = x.day in
  m >= 1 && m <= 12 && d >= 1 &&
  (let dmax =
    match m with
        2 ->
          if y mod 4 = 0 && not (y mod 100 = 0) || y mod 400 = 0 then 29
          else 28
      | 1 | 3 | 5 | 7 | 8 | 10 | 12 -> 31
      | _ -> 30
  in
  d <= dmax)

(* Compare dates chronologically *)
let compare_date a b =
  let c = compare a.year b.year in
  if c <> 0 then c
  else
    let c = compare a.month b.month in
    if c <> 0 then c
    else compare a.day b.day

(* Check that the end_date, when defined, is not earlier than the start_date *)
let validate_job x =
  match x.end_date with
      None -> true
    | Some end_date ->
        compare_date x.start_date end_date <= 0
atd-2.1.0/doc/tutorial.rst000066400000000000000000001115101357165332000154300ustar00rootroot00000000000000********
Tutorial
********

What is atdgen?
===============

Atdgen is a tool that derives OCaml boilerplate code from type definitions.
Currently it provides support for:

* `JSON `_ serialization and deserialization.
* `Biniou `_ serialization and deserialization.
  Biniou is a binary format extensible like JSON but more compact
  and faster to process.
* Convenience functions for creating and validating OCaml data.


What are the advantages of atdgen?
==================================

Atdgen has a number of advantages over its predecessor json-static
which was based on Camlp4:

* produces explicit interfaces which describe what is available to
  the user (`.mli` files).
* produces readable OCaml code that can be easily reviewed
  (`.ml` files).
* produces fast code, 3x faster than json-static.
* runs fast, keeping build times low.
* same ATD definitions can be used to generate code other than
  OCaml. See for instance
  `atdj `_
  which generates Java classes for JSON IO.
  Auto-generating GUI widgets from type definitions is another
  popular use of annotated type definitions. The implementation of
  such code generators is facilitated by the
  `atd `_ library.


Prerequisites
=============

This tutorial assumes that you are using atdgen version 1.5.0 or above.
The following command tells you which version you are using:

::

  $ atdgen -version
  1.5.0

The recommended way of installing atdgen and all its dependencies is with
`opam `_:

::

  $ opam install atdgen


Getting started
===============

From now on we assume that atdgen 1.5.0 or above is installed properly.

::

  $ atdgen -version
  1.5.0

Type definitions are placed in a `.atd` file (`hello.atd`):

.. code-block:: ocaml

  type date = {
    year : int;
    month : int;
    day : int;
  }

Our handwritten OCaml program is ``hello.ml``:

.. code-block:: ocaml

  open Hello_t
  let () =
    let date = { year = 1970; month = 1; day = 1 } in
    print_endline (Hello_j.string_of_date date)

We produce OCaml code from the type definitions using ``atdgen``:

::

  $ atdgen -t hello.atd     # produces OCaml type definitions
  $ atdgen -j hello.atd     # produces OCaml code dealing with JSON

We now have `_t` and `_j` files produced by `atdgen -t` and `atdgen -j`
respectively:

::

  $ ls
  hello.atd  hello.ml  hello_j.ml  hello_j.mli  hello_t.ml  hello_t.mli

We compile all `.mli` and `.ml` files:

::

  $ ocamlfind ocamlc -c hello_t.mli -package atdgen
  $ ocamlfind ocamlc -c hello_j.mli -package atdgen
  $ ocamlfind ocamlopt -c hello_t.ml -package atdgen
  $ ocamlfind ocamlopt -c hello_j.ml -package atdgen
  $ ocamlfind ocamlopt -c hello.ml -package atdgen
  $ ocamlfind ocamlopt -o hello hello_t.cmx hello_j.cmx hello.cmx -package atdgen -linkpkg

And finally we run our `hello` program:

::

  $ ./hello
  {"year":1970,"month":1,"day":1}

`Source code for this section `_

Inspecting and pretty-printing JSON
===================================

Input JSON data:

::

  $ cat single.json
  [1234,"abcde",{"start_date":{"year":1970,"month":1,"day":1},
  "end_date":{"year":1980,"month":1,"day":1}}]

Pretty-printed JSON can be produced with the ``ydump`` command:

::

  $ ydump single.json
  [
    1234,
    "abcde",
    {
      "start_date": { "year": 1970, "month": 1, "day": 1 },
      "end_date": { "year": 1980, "month": 1, "day": 1 }
    }
  ]

Multiple JSON objects separated by whitespace, typically one JSON object
per line, can also be pretty-printed with `ydump`. Input:

::

  $ cat stream.json
  [1234,"abcde",{"start_date":{"year":1970,"month":1,"day":1},
  "end_date":{"year":1980,"month":1,"day":1}}]
  [1,"a",{}]

In this case the `-s` option is required:

::

  $ ydump -s stream.json
  [
    1234,
    "abcde",
    {
      "start_date": { "year": 1970, "month": 1, "day": 1 },
      "end_date": { "year": 1980, "month": 1, "day": 1 }
    }
  ]
  [ 1, "a", {} ]

From an OCaml program, pretty-printing can be done with `Yojson.Safe.prettify`
which has the following signature:

.. code-block:: ocaml

  val prettify : string -> string

We wrote a tiny program that simply calls the `prettify` function on
some predefined JSON data (file `prettify.ml`):

.. code-block:: ocaml

  let json =
  "[1234,\"abcde\",{\"start_date\":{\"year\":1970,\"month\":1,\"day\":1},
  \"end_date\":{\"year\":1980,\"month\":1,\"day\":1}}]"

  let () = print_endline (Yojson.Safe.prettify json)

We now compile and run prettify.ml:

::

  $ ocamlfind ocamlopt -o prettify prettify.ml -package atdgen -linkpkg
  $ ./prettify
  [
    1234,
    "abcde",
    {
      "start_date": { "year": 1970, "month": 1, "day": 1 },
      "end_date": { "year": 1980, "month": 1, "day": 1 }
    }
  ]

`Source code for this section `__



Inspecting biniou data
======================

Biniou is a binary format that can be displayed as text using a generic command
called ``bdump``. The only practical difficulty is to recover the original field
names and variant names which are stored as 31-bit hashes. Unhashing them is
done by consulting a dictionary (list of words) maintained by the user.

Let's first produce a sample data file ``tree.dat`` containing the
biniou representation of a binary tree. In the same program
we will also demonstrate how to render biniou data into text from an
OCaml program.

Here is the ATD file defining our tree type (file ``tree.atd``):

.. code-block:: ocaml

  type tree = [
    | Empty
    | Node of (tree * int * tree)
  ]

This is our OCaml program (file ``tree.ml``):

.. code-block:: ocaml

  open Printf

  (* sample value *)
  let tree : Tree_t.tree =
    `Node (
      `Node (`Empty, 1, `Empty),
      2,
      `Node (
        `Node (`Empty, 3, `Empty),
        4,
        `Node (`Empty, 5, `Empty)
      )
    )

  let () =
    (* write sample value to file *)
    let fname = "tree.dat" in
    Atdgen_runtime.Util.Biniou.to_file Tree_b.write_tree fname tree;

    (* write sample value to string *)
    let s = Tree_b.string_of_tree tree in
    printf "raw value (saved as %s):\n%S\n" fname s;
    printf "length: %i\n" (String.length s);

    printf "pretty-printed value (without dictionary):\n";
    print_endline (Bi_io.view s);

    printf "pretty-printed value (with dictionary):\n";
    let unhash = Bi_io.make_unhash ["Empty"; "Node"; "foo"; "bar" ] in
    print_endline (Bi_io.view ~unhash s)

Compilation:

::

  $ atdgen -t tree.atd
  $ atdgen -b tree.atd
  $ ocamlfind ocamlopt -o tree \
      tree_t.mli tree_t.ml tree_b.mli tree_b.ml tree.ml \
      -package atdgen -linkpkg

Running the program:

::

  $ ./tree
  raw value (saved as tree.dat):
  "\023\179\2276\"\020\003\023\179\2276\"\020\003\023\003\007\170m\017\002\023\003\007\170m\017\004\023\179\2276\"\020\003\023\179\2276\"\020\003\023\003\007\170m\017\006\023\003\007\170m\017\b\023\179\2276\"\020\003\023\003\007\170m\017\n\023\003\007\170m"
  length: 75
  pretty-printed value (without dictionary):
  <#33e33622:
    (<#33e33622: (<#0307aa6d>, 1, <#0307aa6d>)>,
      2,
      <#33e33622:
        (<#33e33622: (<#0307aa6d>, 3, <#0307aa6d>)>,
          4,
          <#33e33622: (<#0307aa6d>, 5, <#0307aa6d>)>)>)>
  pretty-printed value (with dictionary):
  <"Node":
    (<"Node": (<"Empty">, 1, <"Empty">)>,
      2,
      <"Node":
        (<"Node": (<"Empty">, 3, <"Empty">)>,
          4,
          <"Node": (<"Empty">, 5, <"Empty">)>)>)>

Now let's see how to pretty-print any biniou data from the command line.
Our sample data are now in file `tree.dat`:

::

  $ ls -l tree.dat
  -rw-r--r-- 1 martin martin 75 Apr 17 01:46 tree.dat

We use the command ``bdump`` to render our sample biniou data as text:

::

  $ bdump tree.dat
  <#33e33622:
    (<#33e33622: (<#0307aa6d>, 1, <#0307aa6d>)>,
      2,
      <#33e33622:
        (<#33e33622: (<#0307aa6d>, 3, <#0307aa6d>)>,
          4,
          <#33e33622: (<#0307aa6d>, 5, <#0307aa6d>)>)>)>

We got hashes for the variant names ``Empty`` and ``Node``. Let's add them to the
dictionary:

::

  $ bdump -w Empty,Node tree.dat
  <"Node":
    (<"Node": (<"Empty">, 1, <"Empty">)>,
      2,
      <"Node":
        (<"Node": (<"Empty">, 3, <"Empty">)>,
          4,
          <"Node": (<"Empty">, 5, <"Empty">)>)>)>

``bdump`` remembers the dictionary so we don't have to pass the ``-w`` option
anymore (for this user on this machine). The following now works:

::

  $ bdump tree.dat
  <"Node":
    (<"Node": (<"Empty">, 1, <"Empty">)>,
      2,
      <"Node":
        (<"Node": (<"Empty">, 3, <"Empty">)>,
          4,
          <"Node": (<"Empty">, 5, <"Empty">)>)>)>

`Source code for this section `__

Optional fields and default values
==================================

Although OCaml records do not support optional fields, both the JSON
and biniou formats make it possible to omit certain fields on a
per-record basis.

For example the JSON record `{ "x": 0, "y": 0 }` can be more
compactly written as `{}` if the reader knows the default values for
the missing fields `x` and `y`. Here is the corresponding type
definition:

.. code-block:: ocaml

  type vector_v1 = { ~x: int; ~y: int }

``~x`` means that field ``x`` supports a default value. Since we do not specify
the default value ourselves, the built-in default is used, which is 0.

If we want the default to be something else than 0, we just have to specify it
as follows:

.. code-block:: ocaml

  type vector_v2 = {
    ~x : int; (* default x is 1 *)
    ~y: int;                     (* default y is 0 *)
  }


It is also possible to specify optional fields without a default value. For
example, let's add an optional ``z`` field:

.. code-block:: ocaml

  type vector_v3 = {
    ~x: int;
    ~y: int;
    ?z: int option;
  }

The following two examples are valid JSON representations of data of type
``vector_v3``:

.. code-block:: json

  { "x": 2, "y": 2, "z": 3 }  // OCaml: { x = 2; y = 2; z = Some 3 }

.. code-block:: json

  { "x": 2, "y": 2 }          // OCaml: { x = 2; y = 2; z = None }

By default, JSON fields whose value is ``null`` are treated
as missing fields. The following two JSON objects are therefore equivalent:

.. code-block:: json

  { "x": 2, "y": 2, "z": null }
  { "x": 2, "y": 2 }

Note also the difference between ``?z: int option`` and ``~z: int option``:

.. code-block:: ocaml

  type vector_v4 = {
    ~x: int;
    ~y: int;
    ~z: int option;  (* no unwrapping of the JSON field value! *)
  }

Here are valid values of type ``vector_v4``, showing that it is usually not what
is intended:

.. code-block:: json

  { "x": 2, "y": 2, "z": [ "Some", 3 ] }

.. code-block:: json

  { "x": 2, "y": 2, "z": "None" }

.. code-block:: json

  { "x": 2, "y": 2 }


Smooth protocol upgrades
========================

Problem: you have a production system that uses a specific JSON or biniou
format. It may be data files or a client-server pair. You now want to add a
field to a record type or to add a case to a variant type.

Both JSON and biniou allow extra record fields. If the consumer does not know
how to deal with the extra field, the default behavior is to happily ignore it.


Adding or removing an optional record field
-------------------------------------------

.. code-block:: ocaml

  type t = {
    x: int;
    y: int;
  }

Same ``.atd`` source file, edited:

.. code-block:: ocaml

  type t = {
    x: int;
    y: int;
    ~z: int; (* new field *)
  }

* Upgrade producers and consumers in any order
* Converting old data is not required nor useful


Adding a required record field
---------

.. code-block:: ocaml

  type t = {
    x: int;
    y: int;
  }

Same ``.atd`` source file, edited:

.. code-block:: ocaml

  type t = {
    x: int;
    y: int;
    z: int; (* new field *)
  }


* Upgrade all producers before the consumers
* Converting old data requires special-purpose hand-written code


Removing a required record field
--------------------------------

* Upgrade all consumers before the producers
* Converting old data is not required but may save some storage space
  (just read and re-write each record using the new type)

Adding a variant case
---------------------

.. code-block:: ocaml

  type t = [ A | B ]

Same ``.atd`` source file, edited:

.. code-block:: ocaml

  type t = [ A | B | C ]


* Upgrade all consumers before the producers
* Converting old data is not required and would have no effect


Removing a variant case
-----------------------

* Upgrade all producers before the consumers
* Converting old data requires special-purpose hand-written code

Avoiding future problems
------------------------

* In doubt, use records rather than tuples because it makes it possible to add
  or remove any field or to reorder them.
* Do not hesitate to create variant types with only one case or records with
  only one field if you think they might be extended later.

Data validation
===============

Atdgen can be used to produce data validators for all types defined in an ATD
file, based on user-given validators specified only for certain types. A simple
example is:

.. code-block:: ocaml

  type t = string  option

As we can see from this example, the validation function is specified using the
annotation ````, where ``p`` is a predicate ``p : t -> bool``,
returning ``true`` when the value of type ``t`` is valid and ``false``
otherwise.

Calling ``atdgen -v`` on a file containing this specification will produce
a validation function equivalent to the following implementation:

.. code-block:: ocaml

  let validate_t path x =
    match x with
    | None -> None
    | Some x ->
        let msg = "Failed check by fun s -> String.length s >= 8" in
        if (fun s -> String.length s >= 8) x
        then None
        else Some {error_path = path; error_msg = msg}

Let's consider this particular example as an illustration of the general shape
of generated validation functions.

The function takes two arguments: the first, ``path``, is a list indicating
where the second, ``x``, was encountered. As specified by our example ``.atd``
code above, ``x`` has type ``t option``.

The body of the validation function does two things:

1. it checks the value of ``x`` against the validation function specified in our
``.atd`` file, namely, checking whether there is ``Some s``, and verifying that
``s`` is at least 8 characters long if so
2. in the event that the validation check fails, it constructs an appropriate
error record.

In general, generated validation functions for a type ``t`` have a type
equivalent to ``validate_t : path -> t -> error option``, where the ``path``
gives the current location in a data structure and the ``error`` is a record of
the location of, and reason for, validation failure.

A return value of ``None`` indicates successful validation, while ``Some
{error_path; error_msg}`` tells us where and why validation failed.

Let's now consider a more realistic example with complex validators defined in a
separate ``.ml`` file. We will define a data structure representing a section of
a resume recording work experience. We will also define validation functions
that can enforce certain properties to protect against errors and junk data.

In the course of this example, we will manually create the following 3 source
files:

* ``resume.atd``: contains the type definitions with annotations
* ``resume_util.ml``: contains our handwritten validators
* ``resume.ml``: is our main program that creates data and checks it using our
  generated validation functions.

After generating additional code with ``atdgen``, we will end up with the
following OCaml modules:

* ``Resume_t``: generated into ``resume_t.ml`` by ``atdgen -t resume.atd``, this
  provides our OCaml type definitions
* ``Resume_util``: written manually in ``resume_util.ml``, this depends on
  ``Resume_t`` and provides validators we will use in ``resume.atd``
* ``Resume_v``: generated into ``resume_v.ml`` by ``atdgen -v resume.atd``, this
  depends on ``Resume_util`` and ``Resume_t`` and provides a validation function
  for each type
* ``Resume_j``: generated into ``resume_j.ml`` by ``atdgen -j resume.atd``, this
  provides functions to serialize and deserialize data in and out of JSON.
* ``Resume``: written manually in ``resume.ml``, this depends on ``Resume_v``,
  and ``Resume_t``, and makes use of the generated types and validation
  functions.

To begin, we specify type definitions for a data structure representing a resume
in ``resume.atd``:

.. code-block:: ocaml

  type text = string 

  type date = {
    year : int;
    month : int;
    day : int;
  } 

  type job = {
    company : text;
    title : text;
    start_date : date;
    ?end_date : date option;
  } 

  type work_experience = job list

We can now call ``atdgen -t resume.atd`` to generate our ``Resume_t`` module in
``resume_t.ml``, providing our data types. Using these data types, we'll define
the following handwritten validators in ``resume_util.ml`` (note that we've
already referred to these validators in ``resume.atd``):

.. code-block:: ocaml

  open Resume_t

  let ascii_printable c =
    let n = Char.code c in
    n >= 32 && n <= 127

  (*
    Check that string is not empty and contains only ASCII printable
    characters (for the sake of the example; we use UTF-8 these days)
  *)
  let validate_some_text s =
    s <> "" &&
      try
        String.iter (fun c -> if not (ascii_printable c) then raise Exit) s;
        true
      with Exit ->
        false

  (*
    Check that the combination of year, month and day exists in the
    Gregorian calendar.
  *)
  let validate_date x =
    let y = x.year in
    let m = x.month in
    let d = x.day in
    m >= 1 && m <= 12 && d >= 1 &&
    (let dmax =
      match m with
          2 ->
            if y mod 4 = 0 && not (y mod 100 = 0) || y mod 400 = 0 then 29
            else 28
        | 1 | 3 | 5 | 7 | 8 | 10 | 12 -> 31
        | _ -> 30
    in
    d <= dmax)

  (* Compare dates chronologically *)
  let compare_date a b =
    let c = compare a.year b.year in
    if c <> 0 then c
    else
      let c = compare a.month b.month in
      if c <> 0 then c
      else compare a.day b.day

  (* Check that the end_date, when defined, is not earlier than the start_date *)
  let validate_job x =
    match x.end_date with
        None -> true
      | Some end_date ->
          compare_date x.start_date end_date <= 0

After we call ``atdgen -v resume.atd``, the module ``Resume_v`` will be
generated in ``resume_v.ml``, providing the function
``validate_work_experience`` . We can then use this function, along with the
generated ``Resume_j`` in the following program written in ``resume.ml``:

.. code-block:: ocaml

  let check_experience x =
    let is_valid = match Resume_v.validate_work_experience [] x with
      | None -> false
      | _ -> true
    in
    Printf.printf "%s:\n%s\n"
      (if is_valid then "VALID" else "INVALID")
      (Yojson.Safe.prettify (Resume_j.string_of_work_experience x))

  let () =
    (* one valid date *)
    let valid = { Resume_t.year = 2000; month = 2; day = 29 } in
    (* one invalid date *)
    let invalid = { Resume_t.year = 1900; month = 0; day = 0 } in
    (* two more valid dates, created with Resume_v.create_date *)
    let date1 = { Resume_t.year = 2005; month = 8; day = 1 } in
    let date2 = { Resume_t.year = 2006; month = 3; day = 22 } in

    let job = {
      Resume_t.company = "Acme Corp.";
      title = "Tester";
      start_date = date1;
      end_date = Some date2;
    }
    in
    let valid_job = { job with Resume_t.start_date = valid } in
    let invalid_job = { job with Resume_t.end_date = Some invalid } in
    let valid_experience = [ job; valid_job ] in
    let invalid_experience = [ job; invalid_job ] in
    check_experience valid_experience;
    check_experience invalid_experience

Output:

::

  VALID:
  [
    {
      "company": "Acme Corp.",
      "title": "Tester",
      "start_date": { "year": 2005, "month": 8, "day": 1 },
      "end_date": { "year": 2006, "month": 3, "day": 22 }
    },
    {
      "company": "Acme Corp.",
      "title": "Tester",
      "start_date": { "year": 2000, "month": 2, "day": 29 },
      "end_date": { "year": 2006, "month": 3, "day": 22 }
    }
  ]
  INVALID:
  [
    {
      "company": "Acme Corp.",
      "title": "Tester",
      "start_date": { "year": 2005, "month": 8, "day": 1 },
      "end_date": { "year": 2006, "month": 3, "day": 22 }
    },
    {
      "company": "Acme Corp.",
      "title": "Tester",
      "start_date": { "year": 2005, "month": 8, "day": 1 },
      "end_date": { "year": 1900, "month": 0, "day": 0 }
    }

`Source code for this section `__

Modularity: referring to type definitions from another ATD file
===============================================================

It is possible to define types that depend on types defined in other ``.atd``
files. The example below is self-explanatory.

``part1.atd``:

.. code-block:: ocaml

  type t = { x : int; y : int }

``part2.atd``:

.. code-block:: ocaml

  type t1  = abstract
      (*
        Imports type t defined in file part1.atd.
        The local name is t1. Because the local name (t1) is different from the
        original name (t), we must specify the original name using t=.
      *)

  type t2 = t1 list

``part3.atd``:

.. code-block:: ocaml

  type t2  = abstract

  type t3 = {
    name : string;
    ?data : t2 option;
  }

``main.ml``:

.. code-block:: ocaml

  let v = {
    Part3_t.name = "foo";
    data = Some [
      { Part1_t.x = 1; y = 2 };
      { Part1_t.x = 3; y = 4 };
    ]
  }

  let () =
    Atdgen_runtime.Util.Json.to_channel Part3_j.write_t3 stdout v;
    print_newline ()

Output:

.. code-block:: json

  {"name":"foo","data":[{"x":1,"y":2},{"x":3,"y":4}]}

`Source code for this section `__


Managing JSON configuration files
=================================

JSON makes a good format for configuration files because it is human-readable,
easy to modify programmatically and widespread. Here is an example of how to use
atdgen to manage config files.


* **Specifying defaults** is done in the .atd file. See section [Optional fields
  and default values] for details on how to do that.

* **Auto-generating a template config file with default values**: a sample value
  in the OCaml world needs to be created but only fields without default need to
  be specified.

* **Describing the format** is achieved by embedding the .atd type definitions
  in the OCaml program and printing it out on request.

* **Loading a config file and reporting illegal fields** is achieved using the
  JSON deserializers produced by ``atdgen -j``. Option ``-j-strict-fields``
  ensures the misspelled field names are not ignored but reported as errors.

* **Reindenting a config file** is achieved by the pretty-printing function
  ``Yojson.Safe.prettify`` that takes a JSON string and returns an equivalent
  JSON string.

* **Showing implicit (default) settings** is achieved by passing the
  ``-j-defaults`` option to ``atdgen``. The OCaml config data is then serialized
  into JSON containing all fields, including those whose value is the default.

The example uses the following type definitions:

.. code-block:: ocaml

  type config = {
    title : string;
    ?description : string option;
    ~timeout  : int;
    ~credentials : param list
      ;
  }

  type param = {
    name : string
      ;
    key : string
      ;
  }

Our program will perform the following actions:

::

  $ ./config -template
  {
    "title": "",
    "timeout": 10,
    "credentials": [ { "name": "foo", "key": "0123456789abcdef" } ]
  }

  $ ./config -format
  type config = {
    title : string;
    ?description : string option;
    ~timeout  : int;
    ~credentials : param list
      ;
  }

  type param = {
    name : string
      ;
    key : string
      ;
  }

  $ cat sample-config.json
  {
    "title": "Example",
    "credentials": [
      {
        "name": "joeuser",
        "key": "db7c0877bdef3016"
      },
      {
        "name": "tester",
        "key": "09871ff387ac2b10"
      }
    ]
  }

  $ ./config -validate sample-config.json
  {
    "title": "Example",
    "timeout": 10,
    "credentials": [
      { "name": "joeuser", "key": "db7c0877bdef3016" },
      { "name": "tester", "key": "09871ff387ac2b10" }
    ]
  }

This is our `demo.sh` script that builds and runs our example
program called `config`:

::

  #! /bin/sh -e

  set -x

  # Embed the contents of the .atd file into our OCaml program
  echo 'let contents = "\' > config_atd.ml
  sed -e 's/\([\\"]\)/\\\1/g' config.atd >> config_atd.ml
  echo '"' >> config_atd.ml

  # Derive OCaml type definitions from .atd file
  atdgen -t config.atd

  # Derive JSON-related functions from .atd file
  atdgen -j -j-defaults -j-strict-fields config.atd

  # Derive validator from .atd file
  atdgen -v config.atd

  # Compile the OCaml program
  ocamlfind ocamlopt -o config \
    config_t.mli config_t.ml config_j.mli config_j.ml config_v.mli config_v.ml \
    config_atd.ml config.ml -package atdgen -linkpkg

  # Output a sample config
  ./config -template

  # Print the original type definitions
  ./config -format

  # Fail to validate an invalid config file
  ./config -validate bad-config1.json || :

  # Fail to validate another invalid config file (using custom validators)
  ./config -validate bad-config3.json || :

  # Validate, inject missing defaults and pretty-print
  ./config -validate sample-config.json

  This is the hand-written OCaml program. It can be used as a start
  point for a real-world program using a JSON config file:

.. code-block:: ocaml

  open Printf

  let param_template =
    (* Sample item used to populate the template config file *)
    {
      Config_v.name = "foo";
      key = "0123456789abcdef"
    }

  let config_template =
    (*
      Records can be conveniently created using functions generated by
      "atdgen -v".
      Here we use Config_v.create_config to create a record of type
      Config_t.config. The big advantage over creating the record
      directly using the record notation {...} is that we don't have to
      specify default values (such as timeout in this example).
    *)
    Config_v.create_config ~title:"" ~credentials: [param_template] ()

  let make_json_template () =
    (* Thanks to the -j-defaults flag passed to atdgen, even default
      fields will be printed out *)
    let compact_json = Config_j.string_of_config config_template in
    Yojson.Safe.prettify compact_json

  let print_template () =
    print_endline (make_json_template ())

  let print_format () =
    print_string Config_atd.contents

  let validate fname =
    let x =
      try
        (* Read config data structure from JSON file *)
        let x = Atdgen_runtime.Util.Json.from_file Config_j.read_config fname in
        (* Call the validators specified by  *)
        if not (Config_v.validate_config x) then
          failwith "Some fields are invalid"
        else
          x
      with e ->
        (* Print decent error message and exit *)
        let msg =
          match e with
              Failure s
            | Yojson.Json_error s -> s
            | e -> Printexc.to_string e
        in
        eprintf "Error: %s\n%!" msg;
        exit 1
    in
    (* Convert config to compact JSON and pretty-print it.
      ~std:true means that the output will not use extended syntax for
      variants and tuples but only standard JSON. *)
    let json = Yojson.Safe.prettify ~std:true (Config_j.string_of_config x) in
    print_endline json

  type action = Template | Format | Validate of string

  let main () =
    let action = ref Template in
    let options = [
      "-template", Arg.Unit (fun () -> action := Template),
      "
            prints a sample configuration file";

      "-format", Arg.Unit (fun () -> action := Format),
      "
            prints the format specification of the config files (atd format)";

      "-validate", Arg.String (fun s -> action := Validate s),
      "
            reads a config file, validates it, adds default values
            and prints the config nicely to stdout";
    ]
    in
    let usage_msg = sprintf "\
  Usage: %s [-template|-format|-validate ...]
  Demonstration of how to manage JSON configuration files with atdgen.
  "
      Sys.argv.(0)
    in
    let anon_fun s = eprintf "Invalid command parameter %S\n%!" s; exit 1 in
    Arg.parse options anon_fun usage_msg;

    match !action with
        Template -> print_template ()
      | Format -> print_format ()
      | Validate s -> validate s

  let () = main ()

The full source code for this section with examples can be inspected
and `downloaded here `__.


Integration with ocamldoc
=========================

Ocamldoc is a tool that comes with the core OCaml distribution.
It uses comments within `(**` and `*)` to produce
hyperlinked documentation (HTML) of module signatures.

Atdgen can produce `.mli` files with comments in the syntax supported by
ocamldoc but regular ATD comments within `(*` and `*)`
are always discarded
by atdgen. Instead, `` must be used and placed after the
element they describe. The contents of the text field must be UTF8-encoded.

.. code-block:: ocaml

  type point = {
    x : float;
    y : float;
    ~z
      
      : float;
  }
    

is converted into the following `.mli` file with
ocamldoc-compatible comments:

.. code-block:: ocaml

  (**
    Point with optional 3rd dimension.

    OCaml example:

  {v
  let p =
    \{ x = 0.5; y = 1.0; z = 0. \}
  v}
  *)
  type point = {
    x: float;
    y: float;
    z: float (** Optional depth, its default value is [0.0]. *)
  }

The only two forms of markup supported by ```` are ``{{`` ...
``}}`` for inline code and ``{{{`` ... ``}}}`` for a block of preformatted code.

Integration with build systems
==============================

OMake
-----

We provide an `Atdgen plugin `__ for
`OMake `__. It simplifies the compilation rules to a
minimum.

The plugin consists of a self-documented file to copy into a project's root. The
following is a sample ``OMakefile`` for a project using JSON and five source
files (``foo.atd``, ``foo.ml``, ``bar.atd``, ``bar.ml`` and ``main.ml``):

.. code-block:: make

  include Atdgen
    # requires file Atdgen.om

  OCAMLFILES = foo_t foo_j foo bar_t bar_j bar main
    # correspond to the OCaml modules we want to build

  Atdgen(foo bar, -j-std)
  OCamlProgram(foobar, $(OCAMLFILES))

  .DEFAULT: foobar.opt

  .PHONY: clean
  clean:
    rm -f *.cm[ioxa] *.cmx[as] *.[oa] *.opt *.run *~
    rm -f $(ATDGEN_OUTFILES)

Running ``omake`` builds the native code executable ``foobar.opt``.

``omake clean`` removes all the products of compilation including the ``.mli``
and ``.ml`` produced by ``atdgen``.


GNU Make
--------

We provide `Atdgen.mk `__, a generic
makefile that defines the dependencies and rules for generating OCaml ``.mli`` and
``.ml`` files from ``.atd`` files containing type definitions. The ``Atdgen.mk`` file
contains its own documentation.

Here is a sample `Makefile` that takes advantage of
`OCamlMakefile `__:

.. code-block:: make

  .PHONY: default
  default: opt

  ATDGEN_SOURCES = foo.atd bar.atd
  ATDGEN_FLAGS = -j-std
  include Atdgen.mk

  SOURCES = \
    foo_t.mli foo_t.ml foo_j.mli foo_j.ml \
    bar_t.mli bar_t.ml bar_j.mli bar_j.ml \
    hello.ml
  RESULT = hello
  PACKS = atdgen
  # "include OCamlMakefile" must come after defs for SOURCES, RESULT, PACKS, etc.
  include OCamlMakefile

  .PHONY: sources opt all
  sources: $(SOURCES)
  opt: sources
          $(MAKE) native-code
  all: sources
          $(MAKE) byte-code

``make`` alone builds a native code executable from source files ``foo.atd``,
``bar.atd`` and ``hello.ml``. ``make clean`` removes generated files. ``make
all`` builds a bytecode executable.

In addition to ``native-code``, ``byte-code`` and ``clean``, ``OCamlMakefile``
provides a number of other targets and options which are documented in
``OCamlMakefile``'s README.

Ocamlbuild
----------

There is an `atdgen plugin for ocamlbuild `__.

Dune (formerly jbuilder)
------------------------

Dune currently needs atdgen build rules specified manually. Given an ``example.atd``,
this will usually look like:

.. code-block:: scheme

  (rule
   (targets example_j.ml
            example_j.mli)
   (deps    example.atd)
   (action  (run atdgen -j -j-std %{deps})))

  (rule
   (targets example_t.ml
            example_t.mli)
   (deps    example.atd)
   (action  (run atdgen -t %{deps})))

You can refer to ``example_t.ml`` and ``example_j.ml`` as usual (by default, they
will be automatically linked into the library being built in the same directory).
You will need to write rules for each .atd file individually until
`Dune supports wildcard rules `_.

Note that any options ``atdgen`` supports can be included in the ``run atdgen``
section (``-open``, ``-deriving-conv``, etc.).

Dealing with untypable JSON
===========================

Sometimes we have to deal with JSON data that cannot be described
using type definitions. In such case, we can represent the data as its
JSON abstract syntax tree (AST), which lets the user inspect it at runtime.

Let's consider a list of JSON objects for which we don't know the type
definitions, but somehow some other system knows how to deal with such
data. Here is such data:

.. code-block:: json

  [
    {
      "label": "flower",
      "value": {
        "petals": [12, 45, 83.5555],
        "water": "a340bcf02e"
      }
    },
    {
      "label": "flower",
      "value": {
        "petals": "undefined",
        "fold": null,
        "water": 0
      }
    },
    { "labels": ["fork", "scissors"],
      "value": [ 8, 8 ]
    }
  ]

Hopefully this means something for someone. We are going to assume that each
object has a ``value`` field of an unknown type, and may have a field ``label``
or a field ``labels`` of type ``string``:

.. code-block:: ocaml

  (* File untypable.atd *)

  type json  = abstract
    (* uses type Yojson.Safe.t,
      with the functions Yojson.Safe.write_json
      and Yojson.Safe.read_json *)

  type obj_list = obj list

  type obj = {
    ?label: string option;
    ?labels: string list option;
    value: json
  }

It is possible to give a different name than ``json`` to the type of the JSON
AST, but then the name of the type used in the original module must be provided
in the annotation, i.e.:

.. code-block:: ocaml

  type raw_json  = abstract
    (* uses type Yojson.Safe.t,
      with the functions Yojson.Safe.write_json
      and Yojson.Safe.read_json *)

  type obj_list = obj list

  type obj = {
    ?label: string option;
    ?labels: string list option;
    value: raw_json
  }

Compile the example with:

::

  $ atdgen -t untypable.atd
  $ atdgen -j -j-std untypable.atd
  $ ocamlfind ocamlc -a -o untypable.cma -package atdgen \
      untypable_t.mli untypable_t.ml untypable_j.mli untypable_j.ml

Test the example with your favorite OCaml toplevel (``ocaml`` or ``utop``):

.. code-block:: ocaml

  # #use "topfind";;
  # #require "atdgen";;
  # #load "untypable.cma";;
  # Atdgen_runtime.Util.Json.from_channel Untypable_j.read_obj_list stdin;;
  [
    {
      "label": "flower",
      "value": {
        "petals": [12, 45, 83.5555],
        "water": "a340bcf02e"
      }
    },
    {
      "label": "flower",
      "value": {
        "petals": "undefined",
        "fold": null,
        "water": 0
      }
    },
    { "labels": ["fork", "scissors"],
      "value": [ 8, 8 ]
    }
  ]
  - : Untypable_t.obj_list =
  [{Untypable_t.label = Some "flower"; labels = None;
    value =
    `Assoc
      [("petals", `List [`Int 12; `Int 45; `Float 83.5555]);
        ("water", `String "a340bcf02e")]};
  {Untypable_t.label = Some "flower"; labels = None;
    value =
    `Assoc [("petals", `String "undefined");
            ("fold", `Null);
            ("water", `Int 0)]};
  {Untypable_t.label = None; labels = Some ["fork"; "scissors"];
    value = `List [`Int 8; `Int 8]}]
atd-2.1.0/dune000066400000000000000000000003331357165332000131440ustar00rootroot00000000000000(env
 ;; disable warnings against "Innocuous unused variables"
 ;; enforce the separation between types `string` and `bytes`
 (dev (flags :standard -w -27 -safe-string))
 (release (flags :standard -w -27 -safe-string)))atd-2.1.0/dune-project000066400000000000000000000066051357165332000146200ustar00rootroot00000000000000(lang dune 1.11)
(using menhir 1.0)

(name atd)
(license MIT)

(maintainers "Rudi Grinberg ")

(authors
 "Martin Jambon "
 "David Sheets "
 "Rudi Grinberg "
 "Ivan Jager "
 "Jeff Meister "
 "Carmelo Piccione "
 "Raman Varabets "
 "Mathieu Baudet "
 "Rauan Mayemir "
 "Louis Roché "
 "Brendan Long "
 "Christophe Troestler "
 "Vincent Bernardoff "
 "haoyang ")

(source (github ahrefs/atd))

(generate_opam_files true)

(package
 (name atd)
 (depends
  (ocaml (>= 4.02))
  (dune (>= 1.11))
  menhir
  easy-format
  re)
 (synopsis "Parser for the ATD data format description language")
 (description "\
ATD is the OCaml library providing a parser for the ATD language and various
utilities. ATD stands for Adjustable Type Definitions in reference to its main
property of supporting annotations that allow a good fit with a variety of data
formats. "))

(package
 (name atdgen)
 (depends
  (ocaml (>= 4.02))
  (dune (>= 1.11))
  (atd (>= 2.0.0))
  (atdgen-runtime (>= 2.0.0))
  (biniou (>= 1.0.6))
  (yojson (>= 1.7.0)))
 (synopsis "Generates efficient JSON serializers, deserializers and validators")
 (description "\
Atdgen is a command-line program that takes as input type definitions in the ATD
syntax and produces OCaml code suitable for data serialization and
deserialization.
Two data formats are currently supported, these are biniou and JSON.
Atdgen-biniou and Atdgen-json will refer to Atdgen used in one context or the
other.
Atdgen was designed with efficiency and durability in mind. Software authors are
encouraged to use Atdgen directly and to write tools that may reuse part of
Atdgen’s source code."))

(package
 (name atdgen-runtime)
 (synopsis "Runtime library for code generated by atdgen")
 (description "\
This package should be used only in conjunction with the stdgen code
generator")
 (depends
  (ocaml (>= 4.02))
  (dune (>= 1.11))
  (yojson (>= 1.7.0))
  (biniou (>= 1.0.6))
  re))

(package
 (name atdj)
 (synopsis "Java code generation for ATD")
 (description "\
Atdj is a program that generates a Java interface from type definitions. In
particular, given a set of ATD type definitions, this tool generates a set of
Java classes representing those types with built-in JSON serializers and
deserializers

The primary benefits of using the generated interface, over manually
manipulating JSON strings from within Java, are safety and ease of use.
Specifically, the generated interface offers the following features:

- JSON strings are automatically checked for correctness with respect to the ATD
specification.

- Details such as optional fields and their associated default values are
automatically handled")
 (depends
  (ocaml (>= 4.02))
  (dune (>= 1.11))
  (atd (>= 2.0.0))
  re))

(package
 (name atds)
 (synopsis "ATD Code generator for Scala")
 (description "ATD Code generator for Scala")
 (depends
  (ocaml (>= 4.02))
  (dune (>= 1.11))
  (atd (>= 2.0.0))
  re))

(package
 (name atdgen-codec-runtime)
 (synopsis "Runtime for atdgen generated bucklescript converters")
 (description "\
This library contains the types that are used by atdgen's
bucklescript backend")
 (depends
  (ocaml (>= 4.02))))
atd-2.1.0/dune-workspace.dev000066400000000000000000000002561357165332000157210ustar00rootroot00000000000000(lang dune 1.0)
;; This file is used by `make all-supported-ocaml-versions`
(context (opam (switch 4.04.2)))
(context (opam (switch 4.05.0)))
(context (opam (switch 4.06.1)))atd-2.1.0/internal-doc/000077500000000000000000000000001357165332000146465ustar00rootroot00000000000000atd-2.1.0/internal-doc/README.md000066400000000000000000000042211357165332000161240ustar00rootroot00000000000000Internal documentation
==

This is a collection of guides to help contributors to the ATD
project.

Whenever possible, we prefer to automate things over having people
read documents and follow rules.

Releasing `atd`
--

We use `topkg` to help with the release process. The release process
involves assigning a [version ID](https://semver.org/), tagging a git
commit with this version ID, building an archive,
and publishing the opam packages that use this archive.

1. Install the command-line interface with `opam install topkg-care`.
2. Update `CHANGES.md`.
3. Tag the commit with `git tag `.
4. Create an archive with `topkg distrib`.
5. Upload the archive to Github with `topkg publish distrib`.
6. Run `topkg opam pkg` and grab the `url` file `_build/atd./url`.
7. Update the opam packages in
   [opam-repository](https://github.com/ocaml/opam-repository).

Details and troubleshooting notes:
* (4) the archive is created in `_build`. The version string in
  the file `atdgen-runtime/src/version.ml` of the archive
  should no longer be the `%%VERSION%%` placeholder.
* (5) if two-factor authentication is enabled for your account,
  you may get a 401 Unauthorized error.
  You may follow the [instructions on Github and create an access
  token](https://help.github.com/articles/creating-a-personal-access-token-for-the-command-line/)
  with the scope `public_repo`. Then arrange to put your access token
  in the `TOPKG_GITHUB_AUTH` environment variable when running
  `topkg publish distrib`. If everything works, there will be a new
  release in the "releases" tab/section on Github.
* (7) at this time, it doesn't seem that topkg understands that we
  have four opam packages and not just one, so we don't run
  `topkg opam submit`. Instead, we fork
  [`opam-repository`](https://github.com/ocaml/opam-repository) and
  copy `packages/atd/atd.` to `packages/atd/atd.`. Then
  we edit the dependencies in the `opam` file as needed and we replace
  the `url` file with the one generated at step (6). Repeat for
  `atdgen-runtime`, `atdgen`, and `atdj`. Then make a pull request
  to have your fork/branch merged into the original
  `opam-repository`.
atd-2.1.0/manual/000077500000000000000000000000001357165332000135445ustar00rootroot00000000000000atd-2.1.0/manual/Makefile000066400000000000000000000017401357165332000152060ustar00rootroot00000000000000# `make pdf' requires pdflatex and builds readme.pdf
# `make txt' requires hevea and builds readme.txt
# `make html' requires hevea and builds readme.html

TEXFILES = atd-manual atd-body

.PHONY: all pdf txt html clean

all: pdf txt html
pdf: atd-manual.pdf
txt: atd-manual.txt
html: atd-manual.html

atd-manual.tex: ../atd_version.ml atd-manual.mlx
	OCAMLPATH=../..:$$OCAMLPATH camlmix atd-manual.mlx -o atd-manual.tex

atd-body.tex: ../atd_version.ml macros.ml atd-body.mlx
	OCAMLPATH=../..:$$OCAMLPATH camlmix atd-body.mlx -o atd-body.tex

atd-manual.txt: $(addsuffix .tex, $(TEXFILES))
	rm -f *.aux
	hevea -fix -text atd-manual
	iconv -f ISO_8859-1 -t UTF-8 < atd-manual.txt > ../atd-manual.txt

atd-manual.html: $(addsuffix .tex, $(TEXFILES))
	rm -f *.aux
	hevea -fix atd-manual

atd-manual.pdf: $(addsuffix .tex, $(TEXFILES))
	pdflatex atd-manual
	pdflatex atd-manual

clean:
	rm -f *.aux *.toc *.log *.out *.haux *.htoc *.fls *.mlx.ml \
		atd-manual.pdf atd-manual.txt atd-manual.html
atd-2.1.0/manual/atd-body.mlx000066400000000000000000000401361357165332000157750ustar00rootroot00000000000000% -*- latex -*-

##
#use "topfind";;
#require "caml2html";;
#require "easy-format";;
#directory "..";;
#load "atd.cma";;
#require "unix";;
#use "../atd_version.ml";;
#use "macros.ml";;
##

\section{Introduction}

ATD stands for Adjustable Type Definitions.

## atd () ##
(* This is a sample ATD file *)

type profile = {
  id : string;
  email : string;
  ~email_validated : bool;
  name : string;
  ?real_name : string option;
  ~about_me : string list;
  ?gender : gender option;
  ?date_of_birth : date option;
}

type gender = [ Female | Male ]

type date = {
  year : int;
  month : int;
  day : int;
}
## () ##

ATD is a language for defining data types across multiple programming
languages and multiple data formats.
That's it.

We provide an OCaml library that provides a parser and a collection of
tools that make it easy to write data validators and code generators
based on ATD definitions.

Unlike the big ``frameworks'' that provide ``everything'' in one
monolithic package, we split the problem of data exchange into logical
modules and ATD is one of them.
In particular, we acknowledge that the following pieces have
little in common and should be defined and implemented separately:

\begin{itemize}
\item data type specifications
\item transport protocols
\item serialization formats
\end{itemize}

Ideally we want just one single language for defining data types and
it should accomodate all programming languages and data formats. ATD
can play this role, but its OCaml implementation makes it
particularly easy to translate ATD specifications into other interface
definition languages if needed.

It is however much harder to imagine that a single transport protocol and
a single serialization format would ever become the only ones used.
A reader from the future might wonder why we are even considering
defining a transport protocol and a serialization format together.
This has been a widespread practice at least until the beginning of
the 21st century (ONC RPC, ICE, Thrift, etc.). For mysterious reasons,
people somehow became convinced that calls to remote services should
be made to mimic internal function calls, pretending that nothing
really bad could happen on the way between the caller and the remote
service. Well, I don't let my 3-old daughter go to school by herself
because the definition of the external world is precisely that it is
unsafe.

Data input is by definition unsafe. A program whose internal data is
corrupted should abort but a failed attempt to read external data
should not cause a program to abort. On the contrary, a program should
be very resistent to all forms of data corruption and attacks and
provide the best diagnosis possible when problems with external data
occur.

Because data exchange is critical and involves multiple partners, we
depart from magic programming language-centric or company-centric
approaches. We define ATD, a data type definition language
designed for maximum expressivity, compatibility across languages and
static type checking of programs using such data.


\subsection{Scope}


ATD offers a core syntax for type definitions, i.e. an idealized view
of the structure of data. Types are mapped to each programming
language or data format using language-specific conventions.
Annotations can complete the type definitions in
order to specify options for a particular language.
Annotations are placed in angle brackets after the element they refer to:

## atd () ##
type profile = {
  id : int ;
    (*
       An int here will map to an OCaml int64 instead of
       OCaml's default int type.
       Other languages than OCaml will use their default int type.
    *)

  age : int;
    (* No annotation here, the default int type will be used. *)
}
## () ##

ATD supports:
\begin{itemize}
\item the following atomic types: bool, int, float, string and unit;
\item built-in list and option types;
\item records aka structs with a syntax for optional fields with or
  with default;
\item tuples;
\item sum types aka variant types, algebraic data types or tagged unions;
\item parametrized types;
\item inheritance for both records and sum types;
\item abstract types;
\item arbitrary annotations.
\end{itemize}

ATD by design does not support:
\begin{itemize}
\item function types, function signatures or method signatures;
\item a syntax to represent values;
\item a syntax for submodules.
\end{itemize}


\subsection{Language overview}

ATD was strongly inspired by the type system of ML and OCaml. Such a
type system allows static type checking and type inference, properties
which contribute to the safety and conciseness of the language.

Unlike mainstream languages like Java, C++, C\# or Python to name a
few, languages such as Haskell or OCaml offer sum types,
also known as algebraic data types or variant types. These allow to
specify that an object is of one kind or another without ever
performing dynamic casts.

## atd () ##
(* Example of a sum type in ATD. The vertical bar reads `or'. *)
type shape = [
    Square of float               (* argument: side length *)
  | Rectangle of (float * float)  (* argument: width and height *)
  | Circle of float               (* argument: radius *)
  | Dot                           (* no argument *)
]
## () ##

A notable example of sum types is the predefined option type.
An object of an option type contains either one value of a given type
or nothing. We could define our own {\tt int\_option} type as follows:

## atd () ##
type int_option = [ None | Some of int ]
## () ##

ATD supports parametrized types also known as generics in Java or
templates in C++.  We could define our own generic option type as
follows:

## atd () ##
type 'a opt = [ None | Some of 'a ]
  (* 'a denotes a type parameter. *)

type opt_int = int opt
  (* equivalent to int_option defined in the previous example *)

type opt_string = string opt
  (* same with string instead of int *)
## () ##

In practice we shall use the predefined option type.
The option type is fundamentally different from nullable objects since
the latter don't allow values that would have type {\tt 'a option option}.

ATD also support product types. They come in two forms: tuples and
records:

## atd () ##
type tuple_example = (string * int)

type record_example = {
  name : string;
  age : int;
}
## () ##

Although tuples in theory are not more expressive than
records, they are much more concise and languages that support them
natively usually do not require type definitions.

Finally, ATD supports multiple inheritance which is a simple mechanism
for adding fields to records or variants to sum types:

## atd () ##
type builtin_color = [
    Red | Green | Blue | Yellow
  | Purple | Black | White
]

type rgb = (float * float * float)
type cmyk = (float * float * float * float)

(* Inheritance of variants *)
type color = [
    inherit builtin_color
  | Rgb of rgb
  | Cmyk of cmyk
]
## () ##

## atd () ##
type basic_profile = {
  id : string;
  name : string;
}

(* Inheritance of record fields *)
type full_profile = {
  inherit basic_profile;
  date_of_birth : (int * int * int) option;
  street_address1 : string option;
  street_address2 : string option;
  city : string option;
  zip_code : string option;
  state : string option;
}
## () ##


\subsection{Editing and validating ATD files}

The extension for ATD files is {\tt .atd}. Editing ATD files is best
achieved using an OCaml-friendly editor since the ATD syntax is vastly
compatible with OCaml and uses a subset of OCaml's keywords.

Emacs users can use caml-mode or tuareg-mode to edit ATD files.
Adding the following line to the {\tt \~{}/.emacs} file will
automatically use tuareg-mode when opening a file with a {\tt .atd}
extension:
\begin{verbatim}
(add-to-list 'auto-mode-alist '("\\.atd\\'" . tuareg-mode))
\end{verbatim}

The syntax of an ATD file can be checked with the program
{\tt atdcat} provided with the OCaml library {\tt atd}.
{\tt atdcat} pretty-prints its input data, optionally after some
transformations such as monomorphization or inheritance.
Here is the output of {\tt atdcat -help}:
## shell "PATH=.. atdcat -help" ##


\section{ATD language}

\newcommand\str[1]{\textcolor{CstringColor}{\texttt{#1}}}
\newcommand\lval[1]{\hypertarget{#1}{#1}}
\newcommand\rval[1]{\hyperlink{#1}{#1}}
\newcommand\com[1]{\textit{#1}}

This is a precise description of the syntax of the ATD language, not a
tutorial.

\subsection{Notations}

Lexical and grammatical rules are expressed using a BNF-like syntax.
Graphical terminal symbols use \str{unquoted strings in typewriter font}.
Non-graphical characters use their official uppercase ASCII name such
as LF for the newline character or SPACE for the space character.
Non-terminal symbols use the regular font and link to their
definition.  Parentheses are used for grouping.

The following postfix operators are used to specify repeats:

\begin{tabular}{ll}
x* & 0, 1 or more occurrences of x \\
x? & 0 or 1 occurrence of x \\
x+ & 1 or more occurrences of x \\
\end{tabular}


\subsection{Lexical rules}

ATD does not enforce a particular character encoding other than ASCII
compatibility.  Non-ASCII text and data found in annotations and
in comments may contain arbitrary bytes in the non-ASCII range 128-255
without escaping.  The UTF-8 encoding is however strongly recommended
for all text.  The use of hexadecimal or decimal escape sequences is
recommended for binary data.

An ATD lexer splits its input into a stream of \rval{token}s,
discarding white\rval{space} and \rval{comment}s.

\begin{tabular}{rcll}
\lval{token} & ::= & \rval{keyword}
                   | \rval{lident}
                   | \rval{uident}
                   | \rval{tident}
                   | \rval{string} & \\
\lval{ignorable} & ::= & \rval{space} | \rval{comment}
                       & \com{discarded} \\
\lval{space} & ::= & SPACE | TAB | CR | LF & \\
\lval{blank} & ::= & SPACE | TAB & \\
\lval{comment} & ::= & \str{(*} (\rval{comment} | \rval{string} | byte)*
                       \str{*)} & \\
\lval{lident} & ::= & (\rval{lower} 
                    | \str{\_} \rval{identchar}) \rval{identchar}*
                    & \com{lowercase identifier} \\
\lval{uident} & ::= & \rval{upper} \rval{identchar}*
                    & \com{uppercase identifier} \\
\lval{tident} & ::= & \str{'} \rval{lident} & \com{type parameter} \\
\lval{lower} & ::= & \str{a}...\str{z} & \\
\lval{upper} & ::= & \str{A}...\str{Z} & \\
\lval{identchar} & ::= & \rval{upper} | \rval{lower} | \rval{digit}
                       | \str{\_} | \str{'}& \\
\lval{string} & ::= & \str{"} \rval{substring}* \str{"}
                    & \com{string literal, used in annotations} \\
\lval{substring} & ::= & \str{$\backslash\backslash$}
                       & \com{single backslash} \\
                 &  |  & \str{$\backslash$"}
                       & \com{double quote} \\
                 &  |  & \str{$\backslash$x} \rval{hex} \rval{hex}
                       & \com{single byte in hexadecimal notation} \\
                 &  |  & \str{$\backslash$}
                           \rval{digit} \rval{digit} \rval{digit}
                       & \com{single byte in decimal notation} \\
                 &  |  & \str{$\backslash$n} & \com{LF} \\
                 &  |  & \str{$\backslash$r} & \com{CR} \\
                 &  |  & \str{$\backslash$t} & \com{TAB} \\
                 &  |  & \str{$\backslash$b} & \com{BS} \\
                 &  |  & \str{$\backslash$} CR? LF blank* & \com{discarded} \\
                 &  |  & not-backslash
                 & \com{any byte except \str{$\backslash$} or \str{"}} \\
\lval{digit} & ::= & \str{0}...\str{9} & \\
\lval{hex} & ::= & \str{0}...\str{9} | \str{a}...\str{f} |
                   \str{A}...\str{F} & \\
\lval{keyword} & ::= & \str{(} | \str{)} | \str{[}
                       | \str{]} | \str{\{} | \str{\}}
                       | \str{<} | \str{>} & \\
               &     & | \str{;} | \str{,} | \str{:} | \str{*}
                       | \str{|} | \str{=} | \str{?} | \str{\~{}} & \\
               &     & | \str{type} | \str{of} | \str{inherit}
                     & \com{all keywords} \\
\end{tabular}


\subsection{Grammar}


\begin{tabular}{rcll}
\lval{module} & ::= & \rval{annot}* \rval{typedef}* & \com{entry point} \\

\lval{annot} & ::= & \str{<} \rval{lident} annot-field* \str{>}
                   & \com{annotation} \\

\lval{annot-field} & ::= & (\rval{lident} (\str{=} \rval{string})?) & \\

\lval{typedef} & ::= & \str{type} \rval{params}? lident annot
                       \str{=} \rval{expr}
                     & \com{type definition} \\

\lval{params} & ::= & \rval{tident} & one parameter \\
              &  |  & \str{(} \rval{tident} (\str{,} \rval{tident})+ \str{)}
                    & \com{two or more parameters} \\

\lval{expr} & ::= & \rval{expr-body} \rval{annot}* & \com{type expression} \\
            &  |  & \rval{tident} & \\

\lval{expr-body} & ::= & \rval{args}? \rval{lident} & \\
                 &  |  & \str{(}
                           (\rval{cell} (\str{*} \rval{cell})*)?
                         \str{)} & \com{tuple type} \\
                 &  |  & \str{\{}
                           ((\rval{field} (\str{;} \rval{field})*) \str{;}?)?
                         \str{\}} & \com{record type} \\
                 &  |  & \str{[}
                           (\str{|}? \rval{variant} (\str{|} \rval{variant})*)?
                         \str{]} & \com{sum type} \\
\lval{args} & ::= & \rval{expr} & \com{one argument} \\
            &  |  & \str{(} \rval{expr} (\str{,} \rval{expr})+ \str{)}
                  & \com{two or more arguments} \\

\lval{cell} & ::= & (\rval{annot}+ \str{:})? \rval{expr} & \\

\lval{field} & ::= & (\str{?} | \str{\~{}})? \rval{lident}
                     \str{=} \rval{expr} & \\
             &  |  & \str{inherit} \rval{expr} & \\

\lval{variant} & ::= & \rval{uident} \rval{annot}* \str{of} \rval{expr} & \\
               &  |  & \rval{uident} \rval{annot}* & \\
               &  |  & \str{inherit} \rval{expr} & \\
\end{tabular}



\subsection{Predefined type names}

The following types are considered predefined and may not be
redefined.

\begin{tabular}{ll}
Type name & Intended use \\
\hline
\tt unit & Type of just one value, useful with parametrized types \\
\tt bool & Boolean \\
\tt int & Integer \\
\tt float & Floating-point number \\
\tt string & Sequence of bytes or characters \\
\tt 'a option & Zero or one element \\
\tt 'a list & Collection or sequence of elements \\
\tt 'a shared & Values for which sharing must be preserved \\
\tt abstract & Type defined elsewhere \\
\end{tabular}


\subsection{Shared values}

ATD supports a special type $x$ \texttt{shared} where $x$ can be 
any monomorphic type expression.
It allows notably to represent cyclic values and to enforce that cycles
are preserved during transformations such as serialization.

## atd () ##
(* Example of a simple graph type *)
type shared_node = node shared (* sharing point *)
type graph = shared_node list
type node = {
  label : string;
  neighbors : shared_node list;
}
## () ##

Two shared values that are physically identical must remain physically
identical after any translation from one data format to another.

Each occurrence of a \texttt{shared} type expression in the ATD
source definition defines its own sharing point.
Therefore the following attempt at defining a graph type will not
preserve cycles because two sharing points are defined:

## atd () ##
(* Incorrect definition of a graph type *)
type node = {
  label : string;
  neighbors : node shared (* sharing point 1 *) list;
}

(* Second occurrence of "shared", won't preserve cycles! *)
type graph = node shared (* sharing point 2 *) list
## () ##

There is actually a way of having multiple \texttt{shared}
type expressions using the same sharing point
but this feature is designed for code generators and
should not be used in handwritten ATD definitions.
The technique consists in providing an annotation of the form
\texttt{} where $x$ is any string identifying the sharing
point.
The graph example can be rewritten correctly as:

## atd () ##
type node = {
  label : string;
  neighbors : node shared  list;
}

type graph = node shared  list
## () ##



\section{OCaml \texttt{atd} library}

The documentation for the \texttt{atd} library is available in HTML
form at \url{##= odoc_url ##}.
atd-2.1.0/manual/atd-manual.mlx000066400000000000000000000153511357165332000163160ustar00rootroot00000000000000% -*- latex -*-
##
#use "../atd_version.ml";;
##
\documentclass[letterpaper,10pt]{article}

\usepackage{ae}
\usepackage{hyperref}
\usepackage{hevea}

\usepackage{verbatim}
\usepackage{alltt}

\usepackage[latin1]{inputenc} 
\usepackage[T1]{fontenc}
\usepackage{url}

\usepackage{booktabs}

\title{ATD\\
\textsc{Adjustable Type Definitions}\\
release ##= version ##}
\author{Martin Jambon\\
$\copyright$ 2010 MyLife}
%\date{October 19, 2072}
\pagestyle{headings}

% We suppress indentation at the beginning of each paragraph because paragraphs
% are short and indentation is used heavily for bullet points and code examples
\setlength{\parindent}{0mm}
\setlength{\parskip}{2mm}

% Thickness of top and bottom lines of tables (\toprule, \bottomrule)
\setlength{\heavyrulewidth}{1.5pt}


\usepackage{alltt}
\usepackage{color}
\newcommand\Clinenum[1]{#1}
\definecolor{CconstructorColor}{rgb}{0.00,0.20,0.80}
\newcommand\Cconstructor[1]{\textcolor{CconstructorColor}{#1}}
\definecolor{CcommentColor}{rgb}{0.60,0.00,0.00}
\newcommand\Ccomment[1]{\textcolor{CcommentColor}{#1}}
\definecolor{CstringColor}{rgb}{0.67,0.27,0.27}
\newcommand\Cstring[1]{\textcolor{CstringColor}{#1}}
\newcommand\Cquotation[1]{#1}
\definecolor{CalphakeywordColor}{rgb}{0.50,0.50,0.50}
\newcommand\Calphakeyword[1]{\textcolor{CalphakeywordColor}{#1}}
\newcommand\Cnonalphakeyword[1]{#1}
\definecolor{CandColor}{rgb}{0.00,0.50,0.00}
\newcommand\Cand[1]{\textcolor{CandColor}{#1}}
\definecolor{CasColor}{rgb}{0.00,0.50,0.00}
\newcommand\Cas[1]{\textcolor{CasColor}{#1}}
\definecolor{CclassColor}{rgb}{0.00,0.50,0.00}
\newcommand\Cclass[1]{\textcolor{CclassColor}{#1}}
\definecolor{CconstraintColor}{rgb}{0.00,0.50,0.00}
\newcommand\Cconstraint[1]{\textcolor{CconstraintColor}{#1}}
\definecolor{CexceptionColor}{rgb}{0.00,0.50,0.00}
\newcommand\Cexception[1]{\textcolor{CexceptionColor}{#1}}
\definecolor{CexternalColor}{rgb}{0.00,0.50,0.00}
\newcommand\Cexternal[1]{\textcolor{CexternalColor}{#1}}
\definecolor{CfunColor}{rgb}{0.00,0.50,0.00}
\newcommand\Cfun[1]{\textcolor{CfunColor}{#1}}
\definecolor{CfunctionColor}{rgb}{0.00,0.50,0.00}
\newcommand\Cfunction[1]{\textcolor{CfunctionColor}{#1}}
\definecolor{CfunctorColor}{rgb}{0.00,0.50,0.00}
\newcommand\Cfunctor[1]{\textcolor{CfunctorColor}{#1}}
\definecolor{CinColor}{rgb}{0.00,0.50,0.00}
\newcommand\Cin[1]{\textcolor{CinColor}{#1}}
\definecolor{CinheritColor}{rgb}{0.00,0.50,0.00}
\newcommand\Cinherit[1]{\textcolor{CinheritColor}{#1}}
\definecolor{CinitializerColor}{rgb}{0.00,0.50,0.00}
\newcommand\Cinitializer[1]{\textcolor{CinitializerColor}{#1}}
\definecolor{CletColor}{rgb}{0.00,0.50,0.00}
\newcommand\Clet[1]{\textcolor{CletColor}{#1}}
\definecolor{CmethodColor}{rgb}{0.00,0.50,0.00}
\newcommand\Cmethod[1]{\textcolor{CmethodColor}{#1}}
\definecolor{CmoduleColor}{rgb}{0.00,0.50,0.00}
\newcommand\Cmodule[1]{\textcolor{CmoduleColor}{#1}}
\definecolor{CmutableColor}{rgb}{0.00,0.50,0.00}
\newcommand\Cmutable[1]{\textcolor{CmutableColor}{#1}}
\definecolor{CofColor}{rgb}{0.00,0.50,0.00}
\newcommand\Cof[1]{\textcolor{CofColor}{#1}}
\definecolor{CprivateColor}{rgb}{0.00,0.50,0.00}
\newcommand\Cprivate[1]{\textcolor{CprivateColor}{#1}}
\definecolor{CrecColor}{rgb}{0.00,0.50,0.00}
\newcommand\Crec[1]{\textcolor{CrecColor}{#1}}
\definecolor{CtypeColor}{rgb}{0.00,0.50,0.00}
\newcommand\Ctype[1]{\textcolor{CtypeColor}{#1}}
\definecolor{CvalColor}{rgb}{0.00,0.50,0.00}
\newcommand\Cval[1]{\textcolor{CvalColor}{#1}}
\definecolor{CvirtualColor}{rgb}{0.00,0.50,0.00}
\newcommand\Cvirtual[1]{\textcolor{CvirtualColor}{#1}}
\definecolor{CdoColor}{rgb}{0.47,0.67,0.67}
\newcommand\Cdo[1]{\textcolor{CdoColor}{#1}}
\definecolor{CdoneColor}{rgb}{0.47,0.67,0.67}
\newcommand\Cdone[1]{\textcolor{CdoneColor}{#1}}
\definecolor{CdowntoColor}{rgb}{0.47,0.67,0.67}
\newcommand\Cdownto[1]{\textcolor{CdowntoColor}{#1}}
\definecolor{CelseColor}{rgb}{0.47,0.67,0.67}
\newcommand\Celse[1]{\textcolor{CelseColor}{#1}}
\definecolor{CforColor}{rgb}{0.47,0.67,0.67}
\newcommand\Cfor[1]{\textcolor{CforColor}{#1}}
\definecolor{CifColor}{rgb}{0.47,0.67,0.67}
\newcommand\Cif[1]{\textcolor{CifColor}{#1}}
\definecolor{ClazyColor}{rgb}{0.47,0.67,0.67}
\newcommand\Clazy[1]{\textcolor{ClazyColor}{#1}}
\definecolor{CmatchColor}{rgb}{0.47,0.67,0.67}
\newcommand\Cmatch[1]{\textcolor{CmatchColor}{#1}}
\definecolor{CnewColor}{rgb}{0.47,0.67,0.67}
\newcommand\Cnew[1]{\textcolor{CnewColor}{#1}}
\definecolor{CorColor}{rgb}{0.47,0.67,0.67}
\newcommand\Cor[1]{\textcolor{CorColor}{#1}}
\definecolor{CthenColor}{rgb}{0.47,0.67,0.67}
\newcommand\Cthen[1]{\textcolor{CthenColor}{#1}}
\definecolor{CtoColor}{rgb}{0.47,0.67,0.67}
\newcommand\Cto[1]{\textcolor{CtoColor}{#1}}
\definecolor{CtryColor}{rgb}{0.47,0.67,0.67}
\newcommand\Ctry[1]{\textcolor{CtryColor}{#1}}
\definecolor{CwhenColor}{rgb}{0.47,0.67,0.67}
\newcommand\Cwhen[1]{\textcolor{CwhenColor}{#1}}
\definecolor{CwhileColor}{rgb}{0.47,0.67,0.67}
\newcommand\Cwhile[1]{\textcolor{CwhileColor}{#1}}
\definecolor{CwithColor}{rgb}{0.47,0.67,0.67}
\newcommand\Cwith[1]{\textcolor{CwithColor}{#1}}
\definecolor{CassertColor}{rgb}{0.80,0.60,0.00}
\newcommand\Cassert[1]{\textcolor{CassertColor}{#1}}
\definecolor{CincludeColor}{rgb}{0.80,0.60,0.00}
\newcommand\Cinclude[1]{\textcolor{CincludeColor}{#1}}
\definecolor{CopenColor}{rgb}{0.80,0.60,0.00}
\newcommand\Copen[1]{\textcolor{CopenColor}{#1}}
\definecolor{CbeginColor}{rgb}{0.60,0.00,0.60}
\newcommand\Cbegin[1]{\textcolor{CbeginColor}{#1}}
\definecolor{CendColor}{rgb}{0.60,0.00,0.60}
\newcommand\Cend[1]{\textcolor{CendColor}{#1}}
\definecolor{CobjectColor}{rgb}{0.60,0.00,0.60}
\newcommand\Cobject[1]{\textcolor{CobjectColor}{#1}}
\definecolor{CsigColor}{rgb}{0.60,0.00,0.60}
\newcommand\Csig[1]{\textcolor{CsigColor}{#1}}
\definecolor{CstructColor}{rgb}{0.60,0.00,0.60}
\newcommand\Cstruct[1]{\textcolor{CstructColor}{#1}}
\definecolor{CraiseColor}{rgb}{1.00,0.00,0.00}
\newcommand\Craise[1]{\textcolor{CraiseColor}{#1}}
\definecolor{CasrColor}{rgb}{0.50,0.50,0.50}
\newcommand\Casr[1]{\textcolor{CasrColor}{#1}}
\definecolor{ClandColor}{rgb}{0.50,0.50,0.50}
\newcommand\Cland[1]{\textcolor{ClandColor}{#1}}
\definecolor{ClorColor}{rgb}{0.50,0.50,0.50}
\newcommand\Clor[1]{\textcolor{ClorColor}{#1}}
\definecolor{ClslColor}{rgb}{0.50,0.50,0.50}
\newcommand\Clsl[1]{\textcolor{ClslColor}{#1}}
\definecolor{ClsrColor}{rgb}{0.50,0.50,0.50}
\newcommand\Clsr[1]{\textcolor{ClsrColor}{#1}}
\definecolor{ClxorColor}{rgb}{0.50,0.50,0.50}
\newcommand\Clxor[1]{\textcolor{ClxorColor}{#1}}
\definecolor{CmodColor}{rgb}{0.50,0.50,0.50}
\newcommand\Cmod[1]{\textcolor{CmodColor}{#1}}
\newcommand\Cfalse[1]{#1}
\newcommand\Ctrue[1]{#1}
\definecolor{CbarColor}{rgb}{0.47,0.67,0.67}
\newcommand\Cbar[1]{\textcolor{CbarColor}{#1}}

% not supported by hevea
%\usepackage{amsthm}
%\newtheorem{definition}{Definition}

\begin{document}
\maketitle
\tableofcontents
\include{atd-body}
\end{document}
atd-2.1.0/manual/macros.ml000066400000000000000000000025421357165332000153650ustar00rootroot00000000000000let latex_of_string s =
  let tokens = Caml2html.Input.string s in
  let buf = Buffer.create 1000 in
  Caml2html.Output_latex.ocaml buf tokens;
  Buffer.contents buf

let print_ocaml s =
  print "\\begin{alltt}";
  print (latex_of_string s);
  print "\\end{alltt}"

(* Validate ATD syntax before printing *)
let print_atd s =
  try 
    ignore (Atd.Util.load_string
              ~expand:true ~keep_poly:true
              ~inherit_fields:true ~inherit_variants:true s);
    print_ocaml s
  with e ->
    let msg =
      match e with
          Failure s
        | Atd.Ast.Atd_error s -> s
        | _ -> Printexc.to_string e
    in
    Printf.eprintf "\
*** Invalid ATD ***
%s
*** Error ***
%s

%!"
      s msg;
    raise e

let ocaml () =
  Camlmix.print_with print_ocaml

let atd () =
  Camlmix.print_with print_atd



let read_command_output f s =
  let ic = Unix.open_process_in s in
  (try
     while true do
       f (input_char ic)
     done
   with End_of_file -> ());
  match Unix.close_process_in ic with
      Unix.WEXITED 0 -> ()
    | _ -> invalid_arg ("read_command_output: " ^ s)


let shell s =
  let buf = Buffer.create 100 in
  read_command_output (Buffer.add_char buf) s;
  print "\\begin{verbatim}";
  print (Buffer.contents buf); (* no escaping! *)
  print "\\end{verbatim}"


let odoc_url = 
  "http://oss.wink.com/atd/atd-" ^ version ^ "/odoc/index.html"

\n" (List.rev (from_doc doc)) in
       output_string out str
   | _ -> ()
  );
  output_string out "\n";
  close_out out
atd-2.1.0/atdj/src/atdj_main.ml000066400000000000000000000047141357165332000162660ustar00rootroot00000000000000(* Main *)

open Atd.Import
open Atdj_env

let args_spec env = Arg.align
    [ "-package",
      Arg.String (fun x -> env := { !env with package = x }),
      " Package name of generated files"
    ]

let usage_msg = "Usage: " ^ Sys.argv.(0) ^ "  \nOptions are:"

let make_package_dirs package =
  let re   = Re.Str.regexp "\\." in
  let dirs = Re.Str.split re package in
  List.fold_left
    (fun parent dir ->
       let full_dir = parent ^ "/" ^ dir in
       if Sys.file_exists full_dir then
         if not (Sys.is_directory full_dir) then
           failwith (
             sprintf "Cannot make directory %s: file already exists" full_dir
           )
         else ()
       else
         Unix.mkdir full_dir 0o755;
       full_dir
    )
    "." dirs

let main () =
  Printexc.record_backtrace true;
  let env = ref default_env in

  (* Parse command line options *)
  let args_spec' = args_spec env in
  Arg.parse args_spec'
    (fun x -> env := { !env with input_file = Some x }) usage_msg;
  let env = !env in

  (* Check for input file *)
  let input_file =
    match env.input_file with
      | None   ->
          prerr_endline "No input file specified";
          Arg.usage args_spec' usage_msg;
          exit 1
      | Some x ->
          if not (Filename.check_suffix x ".atd") then (
            prerr_endline "Input filename must end with `.atd'";
            Arg.usage args_spec' usage_msg;
            exit 1
          ) else x in

  (* Validate package name *)
  let re = Re.Str.regexp "^[a-zA-Z0-9]+\\(\\.[a-zA-Z0-9]+\\)*$" in
  if not (Re.Str.string_match re env.package 0) then (
    prerr_endline "Invalid package name";
    Arg.usage args_spec' usage_msg;
    exit 1
  );

  (* Parse ATD file *)
  let (atd_head, atd_module), _original_types =
    Atd.Util.load_file
      ~expand:false ~inherit_fields:true ~inherit_variants:true input_file
  in
  let env = {
    env with
    module_items =
      List.map
        (function (Atd.Ast.Type (_, (name, _, _), atd_ty)) -> (name, atd_ty))
        atd_module
  } in

  (* Create package directories *)
  let env = { env with package_dir = make_package_dirs env.package } in

  (* Generate classes from ATD definition *)
  let env = Atdj_trans.trans_module env atd_module in

  (* Output helper classes *)
  Atdj_helper.output_util env;
  Atdj_helper.output_atdj env;

  Atdj_helper.output_package_javadoc env atd_head


let () =
  try main ()
  with Atd.Ast.Atd_error s as e ->
    eprintf "Error:\n%s\n" s;
    raise e
atd-2.1.0/atdj/src/atdj_names.ml000066400000000000000000000066471357165332000164540ustar00rootroot00000000000000open Atd.Import
(* Names *)

let to_camel_case (s : string) =
  let res    = Bytes.of_string s in
  let offset = ref 0 in
  let upper  = ref true in
  let f = function
    | '_' ->
        upper := true;
    | ('0'|'1'|'2'|'3'|'4'|'5'|'6'|'7'|'8'|'9') as x ->
        upper := true;
        Bytes.set res !offset x;
        incr offset
    | _ as x ->
        if !upper then (
          Bytes.set res !offset (Char.uppercase_ascii x);
          upper := false
        ) else
          Bytes.set res !offset x;
        incr offset in
  String.iter f s;
  Bytes.to_string (Bytes.sub res 0 !offset)

(* Translate type names into idiomatic Java class names.  We special case
 * `string', `int' and `bool'  (see code).  For the remainder, we remove
 * underscores and capitalise any character that is immediately following
 * an underscore or digit.  We also capitalise the initial character
 * e.g. "foo_bar42baz" becomes "FooBar42Baz". *)
let to_class_name str =
  match str with
    | "string" -> "String"
    | "int"    -> "Integer"
    | "bool"   -> "Boolean"
    | "float"  -> "Double"
    | _ -> to_camel_case str

let java_keywords = [
  "abstract";
  "assert";
  "boolean";
  "break";
  "byte";
  "case";
  "catch";
  "char";
  "class";
  "const";
  "continue";
  "default";
  "do";
  "double";
  "else";
  "enum";
  "extends";
  "final";
  "finally";
  "float";
  "for";
  "goto";
  "if";
  "implements";
  "import";
  "instanceof";
  "int";
  "interface";
  "long";
  "native";
  "new";
  "package";
  "private";
  "protected";
  "public";
  "return";
  "short";
  "static";
  "strictfp";
  "super";
  "switch";
  "synchronized";
  "this";
  "throw";
  "throws";
  "transient";
  "try";
  "void";
  "volatile";
  "while";
]

let is_java_keyword =
  let tbl = Hashtbl.create 200 in
  List.iter (fun k -> Hashtbl.add tbl k ()) java_keywords;
  fun k -> Hashtbl.mem tbl k

(*
   Automatically append an underscore to a field name if it is a Java keyword.
   Use the alternative provided as  if available.

   ATD field                           Java name

   not_a_keyword                       not_a_keyword
   class                               class_
   class       class_name
   not_a_keyword    class

*)
let get_java_field_name field_name annot =
  let field_name =
    if is_java_keyword field_name then
      field_name ^ "_"
    else
      field_name
  in
  Atd.Annot.get_field
    ~parse:(fun s -> Some s)
    ~default:field_name
    ~sections:["java"]
    ~field:"name"
    annot

let get_java_variant_names field_name annot =
  let lower_field_name = String.lowercase_ascii field_name in
  let field_name =
    if is_java_keyword lower_field_name then
      field_name ^ "_"
    else
      field_name
  in
  let field_name =
    Atd.Annot.get_field
      ~parse:(fun s -> Some s)
      ~default:field_name
      ~sections:["java"]
      ~field:"name"
      annot
  in
  let func_name = to_camel_case field_name in
  let enum_name = String.uppercase_ascii field_name in
  let private_field_name = String.lowercase_ascii field_name in
  func_name, enum_name, private_field_name

let get_json_field_name field_name annot =
  Atd.Annot.get_field
    ~parse:(fun s -> Some s)
    ~default:field_name
    ~sections:["json"]
    ~field:"name"
    annot

let get_json_variant_name field_name annot =
  Atd.Annot.get_field
    ~parse:(fun s -> Some s)
    ~default:field_name
    ~sections:["json"]
    ~field:"name"
    annot
atd-2.1.0/atdj/src/atdj_trans.ml000066400000000000000000000432711357165332000164720ustar00rootroot00000000000000open Atd.Import
open Atdj_names
open Atdj_env
open Atdj_util
(* Calculate the JSON representation of an ATD type.
 *
 * Values of sum types t are encoded as either Strings or two-element
 * JSONArrays, depending upon the arity of the particular constructor.
 * A nullary constructor C is denoted by the String "C", whilst
 * an application of a unary constructor C to an ATD value v is denoted by the
 * JSONArray ["C", ], where  is the JSON representation of v.
 *
 * Option types other than in optional fields (e.g. '?foo: int option')
 * are not supported.
*)
let json_of_atd env atd_ty =
  let atd_ty = norm_ty ~unwrap_option:true env atd_ty in
  match atd_ty with
  | Sum    _ -> "Object" (* Either a String or a two element JSONArray *)
  | Record _ -> "JSONObject"
  | List   _ -> "JSONArray"
  | Name (_, (_, ty, _), _) ->
      (match ty with
       | "bool"   -> "boolean"
       | "int"    -> "int"
       | "float"  -> "double"
       | "string" -> "String"
       | _        -> type_not_supported atd_ty
      )
  | x -> type_not_supported x

(* Calculate the method name required to extract the JSON representation of an
 * ATD value from either a JSONObject or a JSONArray ("get", "opt",
 * "getInt", "optInt", ...)
*)
let get env atd_ty opt =
  let atd_ty = norm_ty ~unwrap_option:true env atd_ty in
  let prefix = if opt then "opt" else "get" in
  let suffix =
    match atd_ty with
    | Sum _ -> ""
    | _ -> String.capitalize_ascii (json_of_atd env atd_ty) in
  prefix ^ suffix

let extract_from_edgy_brackets s =
  Re.Str.global_replace
    (Re.Str.regexp "^[^<]*<\\|>[^>]*$") "" s
(*
extract_from_edgy_brackets "ab>f";;
- : string = "cd"
*)

(* Assignment with translation.  Suppose that atd_ty is an ATD type, with
 * corresponding Java and (Javafied) JSON types java_ty and json_ty. Then this
 * function assigns to a variable `dst' of type java_ty from a variable `src' of
 * type `json_ty'.
*)
let rec assign env opt_dst src java_ty atd_ty indent =
  let atd_ty = norm_ty env atd_ty in
  match opt_dst with
  | None ->
      (match atd_ty with
       | Sum _ ->
           sprintf "new %s(%s)" java_ty src
       | Record _ ->
           sprintf "new %s(%s)" java_ty src
       | Name (_, (_, ty, _), _) ->
           (match ty with
            | "bool" | "int" | "float" | "string" -> src
            | _  -> type_not_supported atd_ty
           )
       | x -> type_not_supported x
      )
  | Some dst ->
      (match atd_ty with
       | Sum _ ->
           sprintf "%s%s = new %s(%s);\n" indent dst java_ty src
       | Record _ ->
           sprintf "%s%s = new %s(%s);\n" indent dst java_ty src
       | List (_, sub_ty, _) ->
           let java_sub_ty = (*ahem*) extract_from_edgy_brackets java_ty in
           let sub_expr = assign env None "_tmp" java_sub_ty sub_ty "" in

           sprintf "%s%s = new %s();\n" indent dst java_ty
           ^ sprintf "%sfor (int _i = 0; _i < %s.length(); ++_i) {\n" indent src

           ^ sprintf "%s  %s _tmp = %s.%s(_i);\n" indent
             (json_of_atd env sub_ty) src (get env sub_ty false)

           ^ sprintf "%s  %s.add(%s);\n" indent
             dst sub_expr
           ^ sprintf "%s}\n" indent

       | Name (_, (_, ty, _), _) ->
           (match ty with
            | "bool" | "int" | "float" | "string" ->
                sprintf "%s%s = %s;\n" indent dst src
            | _  -> type_not_supported atd_ty
           )
       | x -> type_not_supported x
      )

(* Assign from an object field, with support for optional fields.  The are two
 * kinds of optional fields: `With_default (~) and `Optional (?).  For both
 * kinds, we return the following values if the field is absent:
 *
 *   bool   -> false
 *   int    -> 0
 *   float  -> 0.0
 *   string -> ""
 *   list   -> []
 *   option -> None
 *
 * Optional fields of record and sum types are not supported. They are
 * treated as required fields.
 *
 * Fields of the `Optional kind extend this behaviour by automatically lifting
 * values of type t to option t by wrapping within a `Some'.
 * Hence `Optional may only be applied to fields of type option t.
 * Note that absent fields are still
 * assigned `None', as before.
 *
 * For `With_default fields, of types bool, int, float, string and list, we use
 * the org.json opt methods to extract the field.  These methods already return
 * the appropriate defaults if field is absent.  For option types, we manually
 * check for the field and manually create a default.  If the field is present,
 * then we wrap its values as necessary.
*)
let assign_field env
    (`Field (_, (atd_field_name, kind, annots), atd_ty)) java_ty =
  let json_field_name = get_json_field_name atd_field_name annots in
  let field_name = get_java_field_name atd_field_name annots in
  (* Check whether the field is optional *)
  let is_opt =
    match kind with
    | Atd.Ast.Optional
    | With_default -> true
    | Required -> false in
  let src = sprintf "jo.%s(\"%s\")" (get env atd_ty is_opt) json_field_name in
  if not is_opt then
    assign env (Some field_name) src java_ty atd_ty "    "
  else
    let mk_else = function
      | Some default ->
          sprintf "    } else {\n      %s = %s;\n    }\n"
            field_name default
      | None ->
          "    }\n"
    in
    let opt_set_default =
      match kind with
      | Atd.Ast.With_default ->
          (match norm_ty ~unwrap_option:true env atd_ty with
           | Name (_, (_, name, _), _) ->
               (match name with
                | "bool" -> mk_else (Some "false")
                | "int" -> mk_else (Some "0")
                | "float" -> mk_else (Some "0.0")
                | "string" -> mk_else (Some "\"\"")
                | _ -> mk_else None (* TODO: fail if no default is provided *)
               )
           | List _ ->
               (* java_ty is supposed to be of the form "ArrayList<...>" *)
               mk_else (Some (sprintf "new %s()" java_ty))
           | _ ->
               mk_else None (* TODO: fail if no default is provided *)
          )
      | _ ->
          mk_else None
    in
    let atd_ty = norm_ty ~unwrap_option:true env atd_ty in
    sprintf "    if (jo.has(\"%s\")) {\n" json_field_name
    ^ assign env (Some field_name) src java_ty atd_ty "      "
    ^ opt_set_default


(* Generate a toJsonBuffer command *)
let rec to_string env id atd_ty indent =
  let atd_ty = norm_ty env atd_ty in
  match atd_ty with
  | List (_, atd_sub_ty, _) ->
      sprintf "%s_out.append(\"[\");\n" indent
      ^ sprintf "%sfor (int i = 0; i < %s.size(); ++i) {\n" indent id
      ^ to_string env (id ^ ".get(i)") atd_sub_ty (indent ^ "  ")
      ^ sprintf "%s  if (i < %s.size() - 1)\n" indent id
      ^ sprintf "%s    _out.append(\",\");\n" indent
      ^ sprintf "%s}\n" indent
      ^ sprintf "%s_out.append(\"]\");\n" indent
  | Name (_, (_, "string", _), _) ->
      (* TODO Check that this is the correct behaviour *)
      sprintf
        "%sUtil.writeJsonString(_out, %s);\n"
        indent id
  | Name _ ->
      sprintf "%s_out.append(String.valueOf(%s));\n" indent id
  | _ ->
      sprintf "%s%s.toJsonBuffer(_out);\n" indent id

(* Generate a toJsonBuffer command for a record field. *)
let to_string_field env = function
  | (`Field (_, (atd_field_name, kind, annots), atd_ty)) ->
      let json_field_name = get_json_field_name atd_field_name annots in
      let field_name = get_java_field_name atd_field_name annots in
      let atd_ty = norm_ty ~unwrap_option:true env atd_ty in
      (* In the case of an optional field, create a predicate to test whether
       * the field has its default value. *)
      let if_part =
        sprintf "
    if (%s != null) {
      if (_isFirst)
        _isFirst = false;
      else
        _out.append(\",\");
      _out.append(\"\\\"%s\\\":\");
%s    }
"
          field_name
          json_field_name
          (to_string env field_name atd_ty "      ")
      in
      let else_part =
        let is_opt =
          match kind with
          | Atd.Ast.Optional | With_default -> true
          | Required -> false in
        if is_opt then
          ""
        else
          sprintf "    \
                   else
      throw new JSONException(\"Uninitialized field %s\");
"
            field_name
      in
      if_part ^ else_part

(* Generate a javadoc comment *)
let javadoc loc annots indent =
  let from_inline_text text = indent ^ " * " ^ text ^ "\n" in
  (* Assume that code is the name of a field that is defined
     in the same class *)
  let from_inline_code code = indent ^ " * {@link #" ^ code ^ "}\n" in
  let from_doc_para =
    List.fold_left (fun acc -> function
      | Atd.Doc.Text text -> (from_inline_text text) :: acc
      | Code code -> (from_inline_code code) :: acc
    ) in
  let from_doc =
    List.fold_left (fun acc -> function
      | Atd.Doc.Paragraph para -> from_doc_para acc para
      | Pre _ -> failwith "Preformatted doc blocks are not supported"
    ) []
  in
  (match Atd.Doc.get_doc loc annots with
   | Some doc ->
       let header = indent ^ "/**\n" in
       let footer = indent ^ " */\n" in
       let body   =
         String.concat "" (List.rev (from_doc doc)) in
       header ^ body ^ footer
   | None     -> ""
  )


(* ------------------------------------------------------------------------- *)
(* Translation of ATD types into Java types *)

(* For option, sum and record types, we generate a Java class.  Each such class
 * implements the following interface:
 *
 *  interface Atdj {
 *    String toJson() throws JSONException;
 *    void toJsonBuffer(StringBuilder out) throws JSONException;
 *  }
 *
 * The toJson() method outputs a JSON representation of the
 * associated value.
 *
 * Each class also has a String constructor for a JSON string as well as a
 * constructor from the corresponding org.json type (see json_of_atd, above).
 *
 * We do not generate classes for types bool, int, float, string and list;
 * instead we `inline' these types directly into the class in which they
 * occur.  We do this so that the Java programmer can access such values
 * directly, thereby avoiding the overhead of having to manually unbox each such
 * value upon access.
*)

let open_class env cname =
  let out = open_out (env.package_dir ^ "/" ^ cname ^ ".java") in
  fprintf out "\
// Automatically generated; do not edit
package %s;
import org.json.*;

"
    env.package;
  out

let rec trans_module env items = List.fold_left trans_outer env items

and trans_outer env (Atd.Ast.Type (_, (name, _, _), atd_ty)) =
  match unwrap atd_ty with
  | Sum (loc, v, a) ->
      trans_sum name env (loc, v, a)
  | Record (loc, v, a) ->
      trans_record name env (loc, v, a)
  | Name (_, (_, _name, _), _) ->
      (* Don't translate primitive types at the top-level *)
      env
  | x -> type_not_supported x

(* Translation of sum types.  For a sum type
 *
 *   type ty = Foo | Bar of whatever
 *
 * we generate a class Ty implemented in Ty.java and an enum TyEnum defined
 * in a separate file TyTag.java.
*)
and trans_sum my_name env (_, vars, _) =
  let class_name = Atdj_names.to_class_name my_name in

  let cases = List.map (function
    | Atd.Ast.Variant (_, (atd_name, an), opt_ty) ->
        let json_name = get_json_variant_name atd_name an in
        let func_name, enum_name, field_name =
          get_java_variant_names atd_name an in
        let opt_java_ty =
          opt_ty |> Option.map (fun ty ->
            let (java_ty, _) = trans_inner env (unwrap_option env ty) in
            (ty, java_ty)
          ) in
        (json_name, func_name, enum_name, field_name, opt_java_ty)
    | Inherit _ -> assert false
  ) vars
  in

  let tags = List.map (fun (_, _, enum_name, _, _) -> enum_name) cases in

  let out = open_class env class_name in

  fprintf out "\
/**
 * Construct objects of type %s.
 */

public class %s {
  Tag t = null;

  public %s() {
  }

  public Tag tag() {
    return t;
  }
"
    my_name
    class_name
    class_name;

  fprintf out "
  /**
   * Define tags for sum type %s.
   */
  public enum Tag {
    %s
  }
"
    my_name
    (String.concat ", " tags);

  fprintf out "
  public %s(Object o) throws JSONException {
    String tag = Util.extractTag(o);
   %a
      throw new JSONException(\"Invalid tag: \" + tag);
  }
"
    class_name
    (fun out l ->
       List.iter (fun (json_name, _func_name, enum_name, field_name, opt_ty) ->
         match opt_ty with
         | None ->
             fprintf out " \
                          if (tag.equals(\"%s\"))
      t = Tag.%s;
    else"
               json_name (* TODO: java-string-escape this *)
               enum_name

         | Some (atd_ty, java_ty) ->
             let src = sprintf "((JSONArray)o).%s(1)" (get env atd_ty false) in
             let set_value =
               assign env
                 (Some ("field_" ^ field_name)) src
                 java_ty atd_ty "      "
             in
             fprintf out " \
                          if (tag.equals(\"%s\")) {
%s
      t = Tag.%s;
    }
    else"
               json_name (* TODO: java-string-escape this *)
               set_value
               enum_name
       ) l
    ) cases;

  List.iter (fun (_, func_name, enum_name, field_name, opt_ty) ->
    match opt_ty with
    | None ->
        fprintf out "
  public void set%s() {
    /* TODO: clear previously-set field and avoid memory leak */
    t = Tag.%s;
  }
"
          func_name
          enum_name;
    | Some (_atd_ty, java_ty) ->
        fprintf out "
  %s field_%s = null;
  public void set%s(%s x) {
    /* TODO: clear previously-set field in order to avoid memory leak */
    t = Tag.%s;
    field_%s = x;
  }
  public %s get%s() {
    if (t == Tag.%s)
      return field_%s;
    else
      return null;
  }
"
          java_ty field_name
          func_name java_ty
          enum_name
          field_name
          java_ty func_name
          enum_name
          field_name;
  ) cases;

  fprintf out "
  public void toJsonBuffer(StringBuilder _out) throws JSONException {
    if (t == null)
      throw new JSONException(\"Uninitialized %s\");
    else {
      switch(t) {%a
      default:
        break; /* unused; keeps compiler happy */
      }
    }
  }

  public String toJson() throws JSONException {
    StringBuilder out = new StringBuilder(128);
    toJsonBuffer(out);
    return out.toString();
  }
"
    class_name
    (fun out l ->
       List.iter (fun (json_name, _func_name, enum_name, field_name, opt_ty) ->
         match opt_ty with
         | None ->
             fprintf out "
      case %s:
        _out.append(\"\\\"%s\\\"\");
        break;"
               enum_name
               json_name (* TODO: java-string-escape *)

         | Some (atd_ty, _) ->
             fprintf out "
      case %s:
         _out.append(\"[\\\"%s\\\",\");
%s         _out.append(\"]\");
         break;"
               enum_name
               json_name
               (to_string env ("field_" ^ field_name) atd_ty "         ")
       ) l
    ) cases;

  fprintf out "}\n";
  close_out out;
  env

(* Translate a record into a Java class.  Each record field becomes a field
 * within the class.
*)
and trans_record my_name env (loc, fields, annots) =
  (* Remove `Inherit values *)
  let fields = List.map
      (function
        | `Field _ as f -> f
        | `Inherit _ -> assert false
      )
      fields in
  (* Translate field types *)
  let (java_tys, env) = List.fold_left
      (fun (java_tys, env) -> function
         | `Field (_, (field_name, _, annots), atd_ty) ->
             let field_name = get_java_field_name field_name annots in
             let (java_ty, env) = trans_inner env (unwrap_option env atd_ty) in
             ((field_name, java_ty) :: java_tys, env)
      )
      ([], env) fields in
  let java_tys = List.rev java_tys in
  (* Output Java class *)
  let class_name = Atdj_names.to_class_name my_name in
  let out = open_class env class_name in
  (* Javadoc *)
  output_string out (javadoc loc annots "");
  fprintf out "\
public class %s implements Atdj {
  /**
   * Construct from a fresh record with null fields.
   */
  public %s() {
  }

  /**
   * Construct from a JSON string.
   */
  public %s(String s) throws JSONException {
    this(new JSONObject(s));
  }

  %s(JSONObject jo) throws JSONException {
"
    class_name
    class_name
    class_name
    class_name;

  let env = List.fold_left
      (fun env (`Field (_, (field_name, _, annots), _) as field) ->
         let field_name = get_java_field_name field_name annots in
         let cmd =
           assign_field env field (List.assoc_exn field_name java_tys) in
         fprintf out "%s" cmd;
         env
      )
      env fields in
  fprintf out "\n  \
               }

  public void toJsonBuffer(StringBuilder _out) throws JSONException {
    boolean _isFirst = true;
    _out.append(\"{\");%a
    _out.append(\"}\");
  }

  public String toJson() throws JSONException {
    StringBuilder out = new StringBuilder(128);
    toJsonBuffer(out);
    return out.toString();
  }
"
    (fun out l ->
       List.iter (fun field ->
         output_string out (to_string_field env field)
       ) l;
    ) fields;

  List.iter
    (function `Field (loc, (field_name, _, annots), _) ->
       let field_name = get_java_field_name field_name annots in
       let java_ty = List.assoc_exn field_name java_tys in
       output_string out (javadoc loc annots "  ");
       fprintf out "  public %s %s;\n" java_ty field_name)
    fields;
  fprintf out "}\n";
  close_out out;
  env

(* Translate an `inner' type i.e. a type that occurs within a record or sum *)
and trans_inner env atd_ty =
  match atd_ty with
  | Name (_, (_, name1, _), _) ->
      (match norm_ty env atd_ty with
       | Name (_, (_, name2, _), _) ->
           (* It's a primitive type e.g. int *)
           (Atdj_names.to_class_name name2, env)
       | _ ->
           (Atdj_names.to_class_name name1, env)
      )
  | List (_, sub_atd_ty, _)  ->
      let (ty', env) = trans_inner env sub_atd_ty in
      ("java.util.ArrayList<" ^ ty' ^ ">", env)
  | x -> type_not_supported x
atd-2.1.0/atdj/src/atdj_util.ml000066400000000000000000000032651357165332000163170ustar00rootroot00000000000000(* Utilities *)

open Atd.Import
open Atdj_env

(* Get rid of `wrap' constructors that we don't support on the Java side yet.
   They could be useful for timestamps, though. *)
let rec unwrap atd_ty =
  match atd_ty with
  | Atd.Ast.Wrap (_, x, _) -> unwrap x
  | x -> x

let rec unwrap_option env atd_ty =
  match atd_ty with
  | Atd.Ast.Wrap (_, x, _) -> unwrap_option env x
  | Option (_, x, _) -> unwrap_option env x
  | x -> x

(* Normalise an ATD type by expanding `top-level' type aliases *)
let rec norm_ty ?(unwrap_option = false) env atd_ty =
  let atd_ty = unwrap atd_ty in
  match atd_ty with
  | Atd.Ast.Name (_, (_, name, _), _) ->
      (match name with
       | "bool" | "int" | "float" | "string" | "abstract" -> atd_ty
       | _ ->
           (match List.assoc name env.module_items with
            | Some x -> norm_ty env x
            | None ->
                eprintf "Warning: unknown type %s\n%!" name;
                atd_ty)
      )
  | Option (_, atd_ty, _) when unwrap_option ->
      norm_ty env atd_ty
  | _ ->
      atd_ty

let not_supported loc =
  Atd.Ast.error_at loc "Construct not yet supported by atdj."

let type_not_supported x =
  let loc = Atd.Ast.loc_of_type_expr x in
  Atd.Ast.error_at loc "Type not supported by atdj."

let warning loc msg =
  let loc_s = Atd.Ast.string_of_loc loc in
  eprintf "\
Warning:
%s
%s
%!"
    loc_s
    msg

(*
   Insert given string ind_S at the beginning of each line from string s.
*)
let indent_block_s =
  let rex = Re.Str.regexp "^" in
  fun ins s ->
    Re.Str.global_replace rex ins s

(*
   Insert n spaces at the beginning of each line from string s.
*)
let indent_block n s =
  let ins = String.make n ' ' in
  indent_block_s ins s
atd-2.1.0/atdj/src/dune000066400000000000000000000001271357165332000146560ustar00rootroot00000000000000(executable
 (name atdj_main)
 (public_name atdj)
 (package atdj)
 (libraries re atd))
atd-2.1.0/atdj/test/000077500000000000000000000000001357165332000141705ustar00rootroot00000000000000atd-2.1.0/atdj/test/AtdjTest.java000066400000000000000000000046661357165332000165710ustar00rootroot00000000000000import java.io.*;
import java.util.*;
import org.json.*;
import org.junit.Test;
import static org.junit.Assert.*;
import com.mylife.test.*;

public class AtdjTest {
  @Test
  public void testSum() throws JSONException {
    SampleSum s = new SampleSum();

    boolean errorDetected;
    try {
      s.toJson();
      errorDetected = false;
    } catch (JSONException e) {
      errorDetected = true;
    }
    assertTrue(errorDetected);

    s.setSimpleTag();
    assertEquals(SampleSum.Tag.SIMPLE_TAG, s.tag());

    SimpleRecord r = new SimpleRecord();
    assertEquals(null, r.o);
    r.o = true;
    assertEquals(true, r.o);

    s.setSimpleRecord(r);
    assertEquals(SampleSum.Tag.SIMPLE_RECORD, s.tag());
    assertTrue(s.getSimpleRecord() != null);
    assertTrue(s.getComplexRecord() == null);
  }

  @Test
  public void testMissingField() throws JSONException {
    ComplexRecord x = new ComplexRecord();
    boolean errorDetected;
    try {
      x.toJson();
      errorDetected = false;
    } catch (JSONException e) {
      errorDetected = true;
    }
    assertTrue(errorDetected);
  }

  @Test
  public void testRecordSerialization() throws JSONException {
    ComplexRecord x = new ComplexRecord();
    x.b = true;
    x.i = -123;
    x.s = "\u0000 Hello!\n\r\t\u007f";
    x.l = new ArrayList();
    x.l.add(true);
    x.l.add(false);
    x.sample_sum = new SampleSum();
    x.sample_sum.setS("Hippopotamus");
    x.class_ = 99;
    /* omitting optional x.final_ */
    x.l2 = new ArrayList();

    String json = x.toJson();
    System.out.println("This is x: " + json);

    ComplexRecord x2 = new ComplexRecord(json);
    String json2 = x2.toJson();
    assertEquals(json, json2);
  }

  @Test
  public void testComplexRecord() throws JSONException {
    ComplexRecord v = new ComplexRecord("{\"b\": true, \"i\": 42, \"s\": \"foo\", \"o\": [\"Some\", true], \"l\": [true, false], \"sample_sum\": \"Simple_tag\", \"l2\":[]}");
    ComplexRecord v2 = new ComplexRecord("{\"b\": true, \"i\": 42, \"s\": \"foo\", \"o\": [\"Some\", true], \"l\": [true, false], \"sample_sum\": [\"Simple_record\",{\"o\":true}], \"l2\":[]}");

    assertEquals(true, v.b);
    v.b = false;
    assertEquals(42, (int)v.i);
    assertEquals("foo", v.s);
    assertEquals(2, v.l.size());
    assertEquals(true, v.l.get(0));
    assertEquals(false, v.l.get(1));
  }

  public static void main(String[] args) {
    org.junit.runner.JUnitCore.main("AtdjTest");
  }
}
atd-2.1.0/atdj/test/com/000077500000000000000000000000001357165332000147465ustar00rootroot00000000000000atd-2.1.0/atdj/test/com/mylife/000077500000000000000000000000001357165332000162335ustar00rootroot00000000000000atd-2.1.0/atdj/test/com/mylife/test/000077500000000000000000000000001357165332000172125ustar00rootroot00000000000000atd-2.1.0/atdj/test/com/mylife/test/dune000066400000000000000000000004321357165332000200670ustar00rootroot00000000000000
(rule
 (targets
  A.java
  Atdj.java
  B.java
  ComplexRecord.java
  E.java
  RecordWithDefaults.java
  SampleSum.java
  SimpleRecord.java
  Util.java
  package.html)
 (deps ../../../test.atd)
 (action
  (chdir
   ../../../
   (run %{bin:atdj} %{deps} -package com.mylife.test))))
atd-2.1.0/atdj/test/dune000066400000000000000000000023471357165332000150540ustar00rootroot00000000000000(alias
 (name runtest)
 (package atdj)
 (action (diff expected/A.java com/mylife/test/A.java)))

(alias
 (name runtest)
 (package atdj)
 (action (diff expected/Atdj.java com/mylife/test/Atdj.java)))

(alias
 (name runtest)
 (package atdj)
 (action (diff expected/B.java com/mylife/test/B.java)))

(alias
 (name runtest)
 (package atdj)
 (action
  (diff expected/ComplexRecord.java com/mylife/test/ComplexRecord.java)))

(alias
 (name runtest)
 (package atdj)
 (action (diff expected/E.java com/mylife/test/E.java)))

(alias
 (name runtest)
 (package atdj)
 (action
  (diff expected/RecordWithDefaults.java com/mylife/test/RecordWithDefaults.java)))

(alias
 (name runtest)
 (package atdj)
 (action (diff expected/SampleSum.java com/mylife/test/SampleSum.java)))

(alias
 (name runtest)
 (package atdj)
 (action (diff expected/SimpleRecord.java com/mylife/test/SimpleRecord.java)))

(alias
 (name runtest)
 (package atdj)
 (action (diff expected/Util.java com/mylife/test/Util.java)))

(alias
 (name runtest)
 (package atdj)
 (action (diff expected/package.html com/mylife/test/package.html)))

(alias
 (name runtest)
 (package atdj)
 (deps
  AtdjTest.java
  json.jar
  junit-4.8.2.jar
  (glob_files com/mylife/test/*.java))
 (action (run ./run_test.sh)))
atd-2.1.0/atdj/test/expected/000077500000000000000000000000001357165332000157715ustar00rootroot00000000000000atd-2.1.0/atdj/test/expected/A.java000066400000000000000000000033431357165332000170170ustar00rootroot00000000000000// Automatically generated; do not edit
package com.mylife.test;
import org.json.*;

/**
 * Construct objects of type a.
 */

public class A {
  Tag t = null;

  public A() {
  }

  public Tag tag() {
    return t;
  }

  /**
   * Define tags for sum type a.
   */
  public enum Tag {
    A
  }

  public A(Object o) throws JSONException {
    String tag = Util.extractTag(o);
    if (tag.equals("A")) {
      field_a = new java.util.ArrayList();
      for (int _i = 0; _i < ((JSONArray)o).getJSONArray(1).length(); ++_i) {
        Object _tmp = ((JSONArray)o).getJSONArray(1).get(_i);
        field_a.add(new B(_tmp));
      }

      t = Tag.A;
    }
    else
      throw new JSONException("Invalid tag: " + tag);
  }

  java.util.ArrayList field_a = null;
  public void setA(java.util.ArrayList x) {
    /* TODO: clear previously-set field in order to avoid memory leak */
    t = Tag.A;
    field_a = x;
  }
  public java.util.ArrayList getA() {
    if (t == Tag.A)
      return field_a;
    else
      return null;
  }

  public void toJsonBuffer(StringBuilder _out) throws JSONException {
    if (t == null)
      throw new JSONException("Uninitialized A");
    else {
      switch(t) {
      case A:
         _out.append("[\"A\",");
         _out.append("[");
         for (int i = 0; i < field_a.size(); ++i) {
           field_a.get(i).toJsonBuffer(_out);
           if (i < field_a.size() - 1)
             _out.append(",");
         }
         _out.append("]");
         _out.append("]");
         break;
      default:
        break; /* unused; keeps compiler happy */
      }
    }
  }

  public String toJson() throws JSONException {
    StringBuilder out = new StringBuilder(128);
    toJsonBuffer(out);
    return out.toString();
  }
}
atd-2.1.0/atdj/test/expected/Atdj.java000066400000000000000000000007651357165332000175260ustar00rootroot00000000000000// Automatically generated; do not edit
package com.mylife.test;
import org.json.*;

/**
 * Common utility interface.
 */
public interface Atdj {
  /**
   * Get the JSON string representation, failing if some of the data
   * was not initialized.
   * @return The JSON string.
   */
  String toJson() throws JSONException;

  /**
   * Write the JSON representation to a buffer, failing if some of the data
   * was not initialized.
   */
  void toJsonBuffer(StringBuilder out) throws JSONException;
}
atd-2.1.0/atdj/test/expected/B.java000066400000000000000000000020421357165332000170130ustar00rootroot00000000000000// Automatically generated; do not edit
package com.mylife.test;
import org.json.*;

/**
 * Construct objects of type b.
 */

public class B {
  Tag t = null;

  public B() {
  }

  public Tag tag() {
    return t;
  }

  /**
   * Define tags for sum type b.
   */
  public enum Tag {
    B
  }

  public B(Object o) throws JSONException {
    String tag = Util.extractTag(o);
    if (tag.equals("B"))
      t = Tag.B;
    else
      throw new JSONException("Invalid tag: " + tag);
  }

  public void setB() {
    /* TODO: clear previously-set field and avoid memory leak */
    t = Tag.B;
  }

  public void toJsonBuffer(StringBuilder _out) throws JSONException {
    if (t == null)
      throw new JSONException("Uninitialized B");
    else {
      switch(t) {
      case B:
        _out.append("\"B\"");
        break;
      default:
        break; /* unused; keeps compiler happy */
      }
    }
  }

  public String toJson() throws JSONException {
    StringBuilder out = new StringBuilder(128);
    toJsonBuffer(out);
    return out.toString();
  }
}
atd-2.1.0/atdj/test/expected/ComplexRecord.java000066400000000000000000000075021357165332000214060ustar00rootroot00000000000000// Automatically generated; do not edit
package com.mylife.test;
import org.json.*;

/**
 * wibble
 */
public class ComplexRecord implements Atdj {
  /**
   * Construct from a fresh record with null fields.
   */
  public ComplexRecord() {
  }

  /**
   * Construct from a JSON string.
   */
  public ComplexRecord(String s) throws JSONException {
    this(new JSONObject(s));
  }

  ComplexRecord(JSONObject jo) throws JSONException {
    b = jo.getBoolean("b");
    i = jo.getInt("i");
    s = jo.getString("s");
    l = new java.util.ArrayList();
    for (int _i = 0; _i < jo.getJSONArray("l").length(); ++_i) {
      boolean _tmp = jo.getJSONArray("l").getBoolean(_i);
      l.add(_tmp);
    }
    sample_sum = new SampleSum(jo.get("sample_sum"));
    if (jo.has("class")) {
      class_ = jo.optInt("class");
    }
    if (jo.has("final")) {
      is_final = jo.optInt("final");
    }
    l2 = new java.util.ArrayList();
    for (int _i = 0; _i < jo.getJSONArray("l2").length(); ++_i) {
      JSONObject _tmp = jo.getJSONArray("l2").getJSONObject(_i);
      l2.add(new RecordWithDefaults(_tmp));
    }

  }

  public void toJsonBuffer(StringBuilder _out) throws JSONException {
    boolean _isFirst = true;
    _out.append("{");
    if (b != null) {
      if (_isFirst)
        _isFirst = false;
      else
        _out.append(",");
      _out.append("\"b\":");
      _out.append(String.valueOf(b));
    }
    else
      throw new JSONException("Uninitialized field b");

    if (i != null) {
      if (_isFirst)
        _isFirst = false;
      else
        _out.append(",");
      _out.append("\"i\":");
      _out.append(String.valueOf(i));
    }
    else
      throw new JSONException("Uninitialized field i");

    if (s != null) {
      if (_isFirst)
        _isFirst = false;
      else
        _out.append(",");
      _out.append("\"s\":");
      Util.writeJsonString(_out, s);
    }
    else
      throw new JSONException("Uninitialized field s");

    if (l != null) {
      if (_isFirst)
        _isFirst = false;
      else
        _out.append(",");
      _out.append("\"l\":");
      _out.append("[");
      for (int i = 0; i < l.size(); ++i) {
        _out.append(String.valueOf(l.get(i)));
        if (i < l.size() - 1)
          _out.append(",");
      }
      _out.append("]");
    }
    else
      throw new JSONException("Uninitialized field l");

    if (sample_sum != null) {
      if (_isFirst)
        _isFirst = false;
      else
        _out.append(",");
      _out.append("\"sample_sum\":");
      sample_sum.toJsonBuffer(_out);
    }
    else
      throw new JSONException("Uninitialized field sample_sum");

    if (class_ != null) {
      if (_isFirst)
        _isFirst = false;
      else
        _out.append(",");
      _out.append("\"class\":");
      _out.append(String.valueOf(class_));
    }

    if (is_final != null) {
      if (_isFirst)
        _isFirst = false;
      else
        _out.append(",");
      _out.append("\"final\":");
      _out.append(String.valueOf(is_final));
    }

    if (l2 != null) {
      if (_isFirst)
        _isFirst = false;
      else
        _out.append(",");
      _out.append("\"l2\":");
      _out.append("[");
      for (int i = 0; i < l2.size(); ++i) {
        l2.get(i).toJsonBuffer(_out);
        if (i < l2.size() - 1)
          _out.append(",");
      }
      _out.append("]");
    }
    else
      throw new JSONException("Uninitialized field l2");

    _out.append("}");
  }

  public String toJson() throws JSONException {
    StringBuilder out = new StringBuilder(128);
    toJsonBuffer(out);
    return out.toString();
  }
  /**
   * foo bar baz
   */
  public Boolean b;
  public Integer i;
  public String s;
  public java.util.ArrayList l;
  public SampleSum sample_sum;
  public Integer class_;
  public Integer is_final;
  public java.util.ArrayList l2;
}
atd-2.1.0/atdj/test/expected/E.java000066400000000000000000000024541357165332000170250ustar00rootroot00000000000000// Automatically generated; do not edit
package com.mylife.test;
import org.json.*;

/**
 * Construct objects of type e.
 */

public class E {
  Tag t = null;

  public E() {
  }

  public Tag tag() {
    return t;
  }

  /**
   * Define tags for sum type e.
   */
  public enum Tag {
    ALPHA, BETA
  }

  public E(Object o) throws JSONException {
    String tag = Util.extractTag(o);
    if (tag.equals("Alpha"))
      t = Tag.ALPHA;
    else if (tag.equals("Beta"))
      t = Tag.BETA;
    else
      throw new JSONException("Invalid tag: " + tag);
  }

  public void setAlpha() {
    /* TODO: clear previously-set field and avoid memory leak */
    t = Tag.ALPHA;
  }

  public void setBeta() {
    /* TODO: clear previously-set field and avoid memory leak */
    t = Tag.BETA;
  }

  public void toJsonBuffer(StringBuilder _out) throws JSONException {
    if (t == null)
      throw new JSONException("Uninitialized E");
    else {
      switch(t) {
      case ALPHA:
        _out.append("\"Alpha\"");
        break;
      case BETA:
        _out.append("\"Beta\"");
        break;
      default:
        break; /* unused; keeps compiler happy */
      }
    }
  }

  public String toJson() throws JSONException {
    StringBuilder out = new StringBuilder(128);
    toJsonBuffer(out);
    return out.toString();
  }
}
atd-2.1.0/atdj/test/expected/RecordWithDefaults.java000066400000000000000000000053521357165332000224030ustar00rootroot00000000000000// Automatically generated; do not edit
package com.mylife.test;
import org.json.*;

public class RecordWithDefaults implements Atdj {
  /**
   * Construct from a fresh record with null fields.
   */
  public RecordWithDefaults() {
  }

  /**
   * Construct from a JSON string.
   */
  public RecordWithDefaults(String s) throws JSONException {
    this(new JSONObject(s));
  }

  RecordWithDefaults(JSONObject jo) throws JSONException {
    if (jo.has("b")) {
      b = jo.optBoolean("b");
    } else {
      b = false;
    }
    if (jo.has("i")) {
      i = jo.optInt("i");
    } else {
      i = 0;
    }
    if (jo.has("s")) {
      s = jo.optString("s");
    } else {
      s = "";
    }
    if (jo.has("o")) {
      o = jo.optBoolean("o");
    } else {
      o = false;
    }
    if (jo.has("l")) {
      l = new java.util.ArrayList();
      for (int _i = 0; _i < jo.optJSONArray("l").length(); ++_i) {
        boolean _tmp = jo.optJSONArray("l").getBoolean(_i);
        l.add(_tmp);
      }
    } else {
      l = new java.util.ArrayList();
    }
    if (jo.has("e")) {
      e = new E(jo.opt("e"));
    }

  }

  public void toJsonBuffer(StringBuilder _out) throws JSONException {
    boolean _isFirst = true;
    _out.append("{");
    if (b != null) {
      if (_isFirst)
        _isFirst = false;
      else
        _out.append(",");
      _out.append("\"b\":");
      _out.append(String.valueOf(b));
    }

    if (i != null) {
      if (_isFirst)
        _isFirst = false;
      else
        _out.append(",");
      _out.append("\"i\":");
      _out.append(String.valueOf(i));
    }

    if (s != null) {
      if (_isFirst)
        _isFirst = false;
      else
        _out.append(",");
      _out.append("\"s\":");
      Util.writeJsonString(_out, s);
    }

    if (o != null) {
      if (_isFirst)
        _isFirst = false;
      else
        _out.append(",");
      _out.append("\"o\":");
      _out.append(String.valueOf(o));
    }

    if (l != null) {
      if (_isFirst)
        _isFirst = false;
      else
        _out.append(",");
      _out.append("\"l\":");
      _out.append("[");
      for (int i = 0; i < l.size(); ++i) {
        _out.append(String.valueOf(l.get(i)));
        if (i < l.size() - 1)
          _out.append(",");
      }
      _out.append("]");
    }

    if (e != null) {
      if (_isFirst)
        _isFirst = false;
      else
        _out.append(",");
      _out.append("\"e\":");
      e.toJsonBuffer(_out);
    }

    _out.append("}");
  }

  public String toJson() throws JSONException {
    StringBuilder out = new StringBuilder(128);
    toJsonBuffer(out);
    return out.toString();
  }
  public Boolean b;
  public Integer i;
  public String s;
  public Boolean o;
  public java.util.ArrayList l;
  public E e;
}
atd-2.1.0/atdj/test/expected/SampleSum.java000066400000000000000000000127351357165332000205520ustar00rootroot00000000000000// Automatically generated; do not edit
package com.mylife.test;
import org.json.*;

/**
 * Construct objects of type sample_sum.
 */

public class SampleSum {
  Tag t = null;

  public SampleSum() {
  }

  public Tag tag() {
    return t;
  }

  /**
   * Define tags for sum type sample_sum.
   */
  public enum Tag {
    SIMPLE_TAG, BOOL, INT_, FLOAT_, S, SIMPLE_RECORD, COMPLEX_RECORD, RECORD_WITH_DEFAULTS
  }

  public SampleSum(Object o) throws JSONException {
    String tag = Util.extractTag(o);
    if (tag.equals("Simple_tag"))
      t = Tag.SIMPLE_TAG;
    else if (tag.equals("Bool")) {
      field_bool = ((JSONArray)o).getBoolean(1);

      t = Tag.BOOL;
    }
    else if (tag.equals("Int")) {
      field_int_ = ((JSONArray)o).getInt(1);

      t = Tag.INT_;
    }
    else if (tag.equals("Float")) {
      field_float_ = ((JSONArray)o).getDouble(1);

      t = Tag.FLOAT_;
    }
    else if (tag.equals("String")) {
      field_s = ((JSONArray)o).getString(1);

      t = Tag.S;
    }
    else if (tag.equals("Simple_record")) {
      field_simple_record = new SimpleRecord(((JSONArray)o).getJSONObject(1));

      t = Tag.SIMPLE_RECORD;
    }
    else if (tag.equals("Complex_record")) {
      field_complex_record = new ComplexRecord(((JSONArray)o).getJSONObject(1));

      t = Tag.COMPLEX_RECORD;
    }
    else if (tag.equals("Record_with_defaults")) {
      field_record_with_defaults = new RecordWithDefaults(((JSONArray)o).getJSONObject(1));

      t = Tag.RECORD_WITH_DEFAULTS;
    }
    else
      throw new JSONException("Invalid tag: " + tag);
  }

  public void setSimpleTag() {
    /* TODO: clear previously-set field and avoid memory leak */
    t = Tag.SIMPLE_TAG;
  }

  Boolean field_bool = null;
  public void setBool(Boolean x) {
    /* TODO: clear previously-set field in order to avoid memory leak */
    t = Tag.BOOL;
    field_bool = x;
  }
  public Boolean getBool() {
    if (t == Tag.BOOL)
      return field_bool;
    else
      return null;
  }

  Integer field_int_ = null;
  public void setInt(Integer x) {
    /* TODO: clear previously-set field in order to avoid memory leak */
    t = Tag.INT_;
    field_int_ = x;
  }
  public Integer getInt() {
    if (t == Tag.INT_)
      return field_int_;
    else
      return null;
  }

  Double field_float_ = null;
  public void setFloat(Double x) {
    /* TODO: clear previously-set field in order to avoid memory leak */
    t = Tag.FLOAT_;
    field_float_ = x;
  }
  public Double getFloat() {
    if (t == Tag.FLOAT_)
      return field_float_;
    else
      return null;
  }

  String field_s = null;
  public void setS(String x) {
    /* TODO: clear previously-set field in order to avoid memory leak */
    t = Tag.S;
    field_s = x;
  }
  public String getS() {
    if (t == Tag.S)
      return field_s;
    else
      return null;
  }

  SimpleRecord field_simple_record = null;
  public void setSimpleRecord(SimpleRecord x) {
    /* TODO: clear previously-set field in order to avoid memory leak */
    t = Tag.SIMPLE_RECORD;
    field_simple_record = x;
  }
  public SimpleRecord getSimpleRecord() {
    if (t == Tag.SIMPLE_RECORD)
      return field_simple_record;
    else
      return null;
  }

  ComplexRecord field_complex_record = null;
  public void setComplexRecord(ComplexRecord x) {
    /* TODO: clear previously-set field in order to avoid memory leak */
    t = Tag.COMPLEX_RECORD;
    field_complex_record = x;
  }
  public ComplexRecord getComplexRecord() {
    if (t == Tag.COMPLEX_RECORD)
      return field_complex_record;
    else
      return null;
  }

  RecordWithDefaults field_record_with_defaults = null;
  public void setRecordWithDefaults(RecordWithDefaults x) {
    /* TODO: clear previously-set field in order to avoid memory leak */
    t = Tag.RECORD_WITH_DEFAULTS;
    field_record_with_defaults = x;
  }
  public RecordWithDefaults getRecordWithDefaults() {
    if (t == Tag.RECORD_WITH_DEFAULTS)
      return field_record_with_defaults;
    else
      return null;
  }

  public void toJsonBuffer(StringBuilder _out) throws JSONException {
    if (t == null)
      throw new JSONException("Uninitialized SampleSum");
    else {
      switch(t) {
      case SIMPLE_TAG:
        _out.append("\"Simple_tag\"");
        break;
      case BOOL:
         _out.append("[\"Bool\",");
         _out.append(String.valueOf(field_bool));
         _out.append("]");
         break;
      case INT_:
         _out.append("[\"Int\",");
         _out.append(String.valueOf(field_int_));
         _out.append("]");
         break;
      case FLOAT_:
         _out.append("[\"Float\",");
         _out.append(String.valueOf(field_float_));
         _out.append("]");
         break;
      case S:
         _out.append("[\"String\",");
         Util.writeJsonString(_out, field_s);
         _out.append("]");
         break;
      case SIMPLE_RECORD:
         _out.append("[\"Simple_record\",");
         field_simple_record.toJsonBuffer(_out);
         _out.append("]");
         break;
      case COMPLEX_RECORD:
         _out.append("[\"Complex_record\",");
         field_complex_record.toJsonBuffer(_out);
         _out.append("]");
         break;
      case RECORD_WITH_DEFAULTS:
         _out.append("[\"Record_with_defaults\",");
         field_record_with_defaults.toJsonBuffer(_out);
         _out.append("]");
         break;
      default:
        break; /* unused; keeps compiler happy */
      }
    }
  }

  public String toJson() throws JSONException {
    StringBuilder out = new StringBuilder(128);
    toJsonBuffer(out);
    return out.toString();
  }
}
atd-2.1.0/atdj/test/expected/SimpleRecord.java000066400000000000000000000017211357165332000212250ustar00rootroot00000000000000// Automatically generated; do not edit
package com.mylife.test;
import org.json.*;

public class SimpleRecord implements Atdj {
  /**
   * Construct from a fresh record with null fields.
   */
  public SimpleRecord() {
  }

  /**
   * Construct from a JSON string.
   */
  public SimpleRecord(String s) throws JSONException {
    this(new JSONObject(s));
  }

  SimpleRecord(JSONObject jo) throws JSONException {
    if (jo.has("o")) {
      o = jo.optBoolean("o");
    }

  }

  public void toJsonBuffer(StringBuilder _out) throws JSONException {
    boolean _isFirst = true;
    _out.append("{");
    if (o != null) {
      if (_isFirst)
        _isFirst = false;
      else
        _out.append(",");
      _out.append("\"o\":");
      _out.append(String.valueOf(o));
    }

    _out.append("}");
  }

  public String toJson() throws JSONException {
    StringBuilder out = new StringBuilder(128);
    toJsonBuffer(out);
    return out.toString();
  }
  public Boolean o;
}
atd-2.1.0/atdj/test/expected/Util.java000066400000000000000000000045741357165332000175630ustar00rootroot00000000000000// Automatically generated; do not edit
package com.mylife.test;
import org.json.*;

class Util {
  // Extract the tag of sum-typed value
  static String extractTag(Object value) throws JSONException {
    if (value instanceof String)
      return (String)value;
    else if (value instanceof JSONArray)
      return ((JSONArray)value).getString(0);
    else throw new JSONException("Cannot extract type");
  }

  // Is an option value a none?
  static boolean isNone(Object value) throws JSONException {
    return (value instanceof String) && (((String)value).equals("None"));
  }

  // Is an option value a Some?
  static boolean isSome(Object value) throws JSONException {
    return (value instanceof JSONArray)
      && ((JSONArray)value).getString(0).equals("Some");
  }

  /*
    Encode a JSON string into a buffer
   */
  static void writeJsonString(StringBuilder out, String s) {
    out.append("\"");
    for (int i = 0; i < s.length(); ++i) {
      char c = s.charAt(i);
      switch (c) {
      case '\b':
        out.append("\\b");
        break;
      case '\f':
        out.append("\\f");
        break;
      case '\n':
        out.append("\\n");
        break;
      case '\r':
        out.append("\\r");
        break;
      case '\t':
        out.append("\\t");
        break;
      case '\\':
        out.append("\\\\");
        break;
      case '"':
        out.append("\\\"");
        break;
      default:
        if (c < 32 || c == 127)
          out.append(String.format("\\u%04x", (int) c));
        else
          out.append(c);
      }
    }
    out.append("\"");
  }

  static String jsonStringOfString(String s) {
    StringBuilder out = new StringBuilder();
    writeJsonString(out, s);
    return out.toString();
  }

  // Unescape escaped backslashes and double quotations.
  // All other escape sequences are considered invalid
  // (this is probably too strict).
  static String unescapeString(String str) throws JSONException {
    StringBuilder buf = new StringBuilder();
    for (int i = 0; i < str.length(); ++i) {
      if (str.charAt(i) == '\\') {
        if (i == str.length() - 1 ||
            (str.charAt(i + 1) != '\\' && str.charAt(i + 1) != '"'))
          throw new JSONException("Invalid escape");
        else {
          buf.append(str.charAt(i + 1));
          ++i;
        }
      } else {
        buf.append(str.charAt(i));
      }
    }
    return buf.toString();
  }
}
atd-2.1.0/atdj/test/expected/package.html000066400000000000000000000000171357165332000202500ustar00rootroot00000000000000

atd-2.1.0/atdj/test/json.jar000066400000000000000000001337251357165332000156520ustar00rootroot00000000000000PKS<	META-INF/PKPKS<META-INF/MANIFEST.MFMLK-.
K-*ϳR03r.JM,IMu	Z(h)f&W+x%irrPKGGPK
.<org/PK
I<	org/json/PK.<org/json/XMLTokener.classWkpSz+@!PSBm1)qm_dY+mBSڦIh!)8iBi		L3MәNg_Ii;N'_̈́ՕlV3{vswٳo{\uc:lv#[ܸ[%٦bwHd$%ㆎ.#7"(Gr5$W$٧ [T>"IT=.Jܨ~9HHJ$$9[*a/dG*1OqQ	O)xZiDa>^=f=VP$\!-ϬH=E6=@?1Zx&1%W7t4L+_pnII{?dniPKh$IKTgt'-,(	|OT)l$uƎ>#Bvb_(IO$v?T]w\wGƚ\o3⋤
~U{qڦPóxN`rg;M=%4gӤC?v!̩/{f0R%#9@m)^n/j}D38[Wuձmg&b{-RGE&Jcm>cy&%}ŃFP:̭aӺmclX,m˶e[-`lܔҧr1؎gy}ϓ(.0^A\u}pσg88;r5JL>2C绅fnBPn Us6Vy32D<8Aޞ V?,X0UncLFS	DWƇ
Y2j)oCewWL&l.S0,LAS0-La;eo~G>3,89f|w0e>7xD?q
[|+E!WߋIXLƟD>Sj1U>,E(1d˶ .pyz7eWҥU!seȔxV\BEUs,Wm5vݫǬLc],Rٝb(7aωUqͱtמsPm,a*/-ŧ_INuR:}Av=5Ρٜ,K`RZ:'V`X
5X*֢FlJGh&тv	E;Ez'""!&va@a8*8&z,d7	\X%-M@Sr\1?J-*t8|dWDneLT֟6)qؼQWPPY4o㯏`Iv|ev55;jx52T0֬Yżaxlq$rPKFN7	APK.<org/json/JSONObject$1.class;o>#vvv.FҢT̜TF~`?IJDk^rN~qf^ojIF~
;7#h~Q~Vq~>B!##g^^jsNbqqj1#ļt}2Fa,Z <V $9PKG뒚PK.<org/json/CookieList.classTVQx"j(HW+R)ԠjkZ@ZhE{Wµg7g?_GT1F!7!)+]mVݣ
EBRֽͷ($>"nz>/t
R*_Jm,I)xk8tvA{g2Tq'pFQ>5bP(1(iCOu͉Ւ
<᪫wZ?>JCULpiV(

ѡOE0NG!gag79iϸKh#Fb@	`	?{WUhWګ]A:{;*ck^;=Дi*f1EH`FAs=L0F
iڹQʔH]	>ejhˣbpw&j0_PK
M&PK.<org/json/JSONTokener.classW{tM/MEiRErHHV@I%&!("CnU"*S
Z'nvm휝~}misy~_ȃz;ʰS|]#%x8nkMi%ͷ
PA/Ke!:¶@qiҖnBكygOcOn6d_ڇ
KNR}fM$Z.N".) ͤ>Lvʫ!wa*K-*.ӏRcWp~]ߏ]L$+.OZ*u[F%F
4R,G~i*nۏzae'zgy.`:
d0Ynxx>Q?{O"c|g?E?NwRD;Eiy܇3VN5&7v	eөC:$庢lmôٺ[(Y
Fɕ0-PY@0X@(PAHWqPC#f.pf{7[>q	q+4pۮ&Ǫ󸪶Jl	T{A^sv{[4v_g;쾍v~KK_/]@Ͷb,/Fۢ~5j֨!YшQ
DzYѐ5j	;Z@١ǰNۘ!QOY9K%(e|{ʍVDGf?ITU3DQUeH!
$负cWAg|TS6
|Mb)LÄ*ʪ$ܐ,WKq$xXj`[§V0K!`"Kp%LS1^QڪQ5zwBDB]F
EC&5D׀j-uXBp2ui6+*څ7ayBۃڵ@"LD
A,h#d=V&}AѠHúdo
\]o־e#Yf
PR";Jݎ5jnRؤEKCJeWYVyܭ~Ճ^u}ꐝK$z¨POT(3X)-YƳɶ|KJ\`yO1*z+"UR֦UhW
FQ&sIwTT|1Q=JG1C>:Kgx+XQ1}֩gЬNhYD%JuaRbs5U԰˖(e(Yl?D^1)LU@멑	6
jP[)V2">99+PKd!
*PK.<org/json/Cookie.classVSW-nZ`4V4!-V|`EyTA%,!qQPJjmk;R[Ag:|c&2uFg鹛)9{hķND8-O=FD1N8*	zcgzǖN߉ NK`.g$es#&bU	b9"A0*!.aLB%L0I)D*apOqCUg"ug'5ONǮebj;!
H#/8l5D<	b&t#0S
%FY1;LŴSiM-(eSŤzֈi	jeO$]DF(vapY5;:220edqAELq	eDQu8lZ'sU!Nj2ઌqMur.ɬƈOdhi58FQFe
)>Jd2ogt/Ŭ|iՠKL%6y-q jS鄡ed|88"D}RMP1HD<>c$=*kf$FQ7YiQ栔0-b_jХ0Ip؞Rqw18D76tZKp^T$m@lnNNwXڙʞҦ>)n&RƼs=jem*Bnޚ8M܃К[PŊC==M<6xp#Gm2_zH?B?#E&]c\_bZwPKyd֥\
PK.<org/json/JSONStringer.class]N@2P覰K1CTXh\h f,:jb$𡌷SHY̜ݹ8
V4PLc55
bHOqr͐h]!k	mmW^99)wsx=3rk;p:wνfl$;	ՌҮ<RO(7Rԑʎ]ṯ#%/{f<ŒraMF|g
ZӴx>8kn'@VBxbk9"/1bc͠j<#T+
P#>#C$_`IXT!YRXΑ#+PKPPK.<org/json/Test$1Obj.classTkOQ=U(V-Ђ"/"YM-.nLD
2ݶܹgΝ?\K.aҋnpÔ;" `R,s>㮈nExpGenWxsoU?<.`CC%izU碕N3J04Uf9%ύC[%#2uR4xsYvʡx%RC5ƛ/P PRl9fLc-	Qs}ITȨ+yZ4#	*nYhFH
x,!~<Ћ>	qEBW5-X:R?߲P*\vy\5s~Uε΢&hn*W}^t֯rt5Rcz/z7PPCeM4~Ll;:)j&%	'b{iZУDbT#Y]3R4r>ƄPq̄4%t2T4:o$d5@Id}yVu>׵"ǙS
^q{AsEweN	'	J8V┸	+U@c-Õt6:NpFB2Y~FoŌr&#
K9IP1"8Wr"ro|`һax=ݩϪ%|ڲԏĭ	j$f.p\ g%b/~/^ǝ\lja	0#7&,dh3[3X(a-ȣψ	Sucބ3+WvJa#>6)ѧ3>7	_K	ߤ<&|%\X%Wk8JO2뤖hW2g?.m;!;?),'y}Lڵ+Gb&a4:qHY[<$N6_0QGG|ȟ+Z^/w,X^	F
:qĠkJHRq
TQRjI=6%̫dYBJ+A6즪ې	mQ'RќɒF21(2N!l#%]T
iV˚QWB&̗Ѕ<]:nl	V׹y#~&jX"Ӭb%y#EKT^5-!uBLV`hd$	)
V(q!÷V訤(k<֫:	؉\Sv"'ڰVX,(>`ݢrf.XMu;5AO?!ЍUۆBs^mg!PثdR
uFE63<^v:Sg1YU1{ׅ,`M/pM0 Iݒ"1_
DB2dVf)2؝Z'%y霶di6l?s̮*B}aE-<Ic7tQ+09DfbK_E}tW,8AR#ʵ+SqTclWѩJ-^WR.ŋ7 TY
o+r*'pNy
)]x_9r47smȋpT,"sǿbK)"UqDY.0"\^,ԛep1R?fgā!1Qc2/7*}YbYsEn|s3D3'MԉɋwOl]LvtLhM&X^^H2)*W2k`%٨r?+ʊUkRS5ցi2\͘NUКZ&ƾVs߫t3	X*3~qCq%uZXj3YcNL#R&FIc[[:)ٓ\qD,ndFQLLg:<َ
ΠҦ7L
E#2GЁ9QP&"C'v!d9НhBFmV ƩGȠ2dTiȥrةh&S%Jh&l#RȨCsZ];Q-,>Zt+rLNAYϿJ|Krߴ
jJ&2S3]I>Ckt-T]wTBѶXXHtJI8]*;sLLa&0鰚:.q=j@`1Ġ(m/xv>;oIaMVcEi,(6mQȴŁ*
ֻ0-{b39&Ie#=${jvNumu2'>:>	5ύI<OCz41Ӷ^|VNaF#-hڊ}7)hh|z7<@0"œ{^a:ct'gыs/0:itR'JixJmqSSL;Q2̚IfWLv]/-}D%XNMY|uY`㡁u-3Yv'?D,J%Ll37NP\+H؂.7FpXCO:cCaS2֝'M\
mꩉLD]pJ_ϗKD0
'vjԘ"uTKU)N
GzCqBغo>2P
ѫwANiZ)Tgx@/O.^bS5VcSզT-7eTk.njKujmJI$Kr;9=q+0`xrlYSVT~ص}JܜJ4$3U?nU66c%ԟJQNS&jXݒBϘ1q
<45 P0
-=$mc`I.xQp˷˄G^Azp۸݂X<;%L4&y27O>kEHGm();Iy)={B^9>1m$1Ypr6w8[Yڢ,8e(xpON/dq`	&r5ӽ\<'_`HnXI3n߬Vucp^J'/t8C$aF
,[JϥK7S\3N<Ύ3v~ۧ}[!
|Xdz`HР
'OuraȇwBG1(WƯ6~}h4.?(IzJ{Im^yeoƇ>~-7~#0qs=)\l1A}[EG:Cr_VU
{V{]I5=(o+pp$<]c|
)%1}z/TW=);%P]=iIxDX[*OJqhP1LQ1@)D^Z⻈.&.K
r5uG/nƽqgxaxw܃Y0G)pFnb\
"_S׾Q؟p
(bʺ#1zy?#f+	bƜ$:ӨPXx3KBD$tFx	
=BKv3(PV`	b|][
('S~…[3@L˴VU'1 Ob2cyuO§muPãF)3s˵-I#L듴^ـor3|ym[
b,GAlI-3&$P_ļ8GH|'jD'2vy aKmpCE=gie+gi=liukO>	(AL֫)$ZOb8Y~myXK!Om';Pvbb~_vs}+3QrǧnQe9m^aVQ
+şpa
7h33~n4.p+.i$g[H+$r5Z/~ZKx9QuTͬu?LQe+^hDͱ@*I=kz!kr.ytotDTTìv.wm>WGt9z:b2u#udXR5{]2e0p7R֗Y&ؔd'MJ|kįP#ilil
X66cN1{pS(1-@*(J$:s*c^z񎆗\A9^;T0ג]%nJ+0<>WE:.fqFQ2sU-~Щlې:sѪOXb-=5#[W}C.+QXOؐUdˤxK6uW֒m]3>aY&g`-5dh'l46W2%>XcţкSx&2ǷioX]M#ʪ(L}:5uOR!TQېoi6OY:4ހoDk`K92:ZZVd;;6uWx2^̑qΎ>gߧxΎ&j[_xƒlbGU7)$GPz#?6Zǟ69A]\rg,gm7/S#yU
uo
9FQor^_4JVq~'l_ۓ_;ZV}ώqo\TUQUFոϥl1qz{(Π*˯gF*ϱ/fJ&"=bN_MYXY"6T6f}9uhg'g뗌 il഼
u]#7U;"O"AU'[a쫪ܾ$"ؓ5]>f+Ye,qJ`dvXO	aei%RX5SW|UeX^'

0.061dXl\02c۱؁mN9`p0v^#nsq#oDYЭr@N)bRyy3){^e"6#W{s_`X+U$δDq0n8\(2nAq+f3n$7%Ƨ3j܍\g܋YD!fܧ1;.ٕz.߅k8obYKPKp#PK.<org/json/CDL.classVkl[g~r8qܺif{uK\I-&͒6N5$uکt)m@ؠLHAܲ_\L7	UBxc']gTX:{{9^N4wWC	is†cnY;9(lbp`Hh8W5Bω9a90*2.)KkbBbpR.8BZd9+

d*PPvG
d93ldÓ=ou\)ē,ȩD&152FJc(,
4u|
VZ.;:::CgYu\%_3,9_³:=&

d}[&+]K2OYsts2$ԨBSْ$3w f[e5}>Mds>Y&xkb@`S|I#5=euj&[I=o-OMڱ mIOe򺔖LcĀ.ܕͿwoHiR342	ZQV3炒-|rgChn6)
aUZyz5CE[}臭[EQ+>1>]GՂ",'ڗ"8(tqp@bt+8Ȓԏ1b54ҩ"ŝBQjFE}Ż:B%{Dv-5徒)	/|D`Ap7UwDFM	D |Dkd	Έ~fPjk]5I̯=@-0Ǹ~>,aϞ{a(~Hwl"vZFL՛p82?IqfЧq*^gTZ=aOkZEkJ~Y~rT=)IY-&Qe{<
W4BSAj}hi|'upk}&j~œ/$X:%B$½%졿{G]wX|[/5wހq7;
T&X1}ro* *8pmԣ#53ʹ/&Vg%g/m!دNJPCP.OUc`ATy*a5l.[BPKKF9PK.<org/json/JSONWriter.classVs^R׶,X	($mJ!$0&@6:Q,kYʃ!@)<ЙN~JX0/0jgwVOÌts9;|~ݻ؄W?z0#f|>
3!9T:#):ut,ȧl? r8*8㸎:qRÃ\#R봆G5<&/V&wH@lhӋ93cx‚I;aq9D1W̎كāVΤRoe1!4(٥njL':Գ\e,C80Ri H+GW]i&3W
Llܺ=)kRlO
~Mmp	\HrY|*43O)9vᝍ50p{rj.uvrIl}W.atu|}]Kl;˖TPa:`Nl_?!O3_Ƚ/կկ`ϸaUUOse-1'EEVR):Z<3\%[EܫkSZOD/E_wKk|w:>LaNf7N"NJz$7&˫f8pC[|w., \n\/U)ZCh۱*n(j"7i%$`okc띌,ƳTB/h!mN
bIh{0/]=u{[XU߈	hbl:瓎ke97Bl(%H3jejRuuˆŐ1vc`PK
PK.<org/json/XML.classW	|&eaI5	(pnv,!
mV`@jA@M=mއ=*oC6q&ơw{ڙǟp^b-vxvx9s6nԙZ[IG7k˃Xŋ"|ԋYb4vXU,|B]^BJ}ߥMݪn|=^^mOާ~mX8}Ϩ-|!=xƒ<CَZxXXxTTc\<3=N~T-u#)rFnNxP,K|W,SU_u7ԎgyVoz--kh^&(m6T
ڪl
%BT$1WnX%W\\M+[ػ\ÖX{+xkD0=Yձ!XLA$u(ޒJN%
oiu	'o)4U<q[8ҙjǒ43H)hޜǪ47o▥Kn	搼#61SAf+RqcX29pi7Aa܌Vm89)oK+\ޮb13uVp7d-^
l7r4=ac$ml[a}|;Z{yMy}pM>qAZM巈_9 Z~WAPB*	
0buKzw`n6ө%(RL2$v%CZC҇ਓe6sxXg0ʃ-"R)+(x".'}B_9z֏BQjq-[H2%3 &<|2h*;&ƹBj]j
ho=q7GI3bJy}:0g&b{Q;7{pa_;0{`}eJN}{,oѽ
.I_~nHUDA;]'}:TT[;D Z3NQ@X%~MC&5y7MA*
a*]X*:Y=:q#)\T/5V?fS5G@8N,s< ffVysp[5Lܛ>Kuܛ/l[X%?_I23|g"F8ў?}{*/pCL)f,MuN+}v2k{{--1̹bü]5ul0^
,1`⺍Icq&ݨb==O{Yb#gd܏`i?x7nQJ|;Ћ>rl?x_qOWV:)xZWe
.\r+4e|"tiįzZvy
{9G+	]NKKS"U^pF^D5RU,.xs/nW*^Wp-uR)>.)q"~/bJA+ ARq /ElO3×HEsnse/"oW"22
ߐu/X04WcR˧Yk3R䞑)~ԭuWL;Uwx)/x
oY/l[sDr>lNxj
}\_p]֕fbݻ1yZz|RY9S09^QcdΓ(P!!̐
X¨V,&F6\%hD(V\/	@ԻYRUye;_CAɟ7!{F|OGnr]r|D%Zr4'EnurnI
5Ƚ>G|\>+w!QyH&.6=1f6XϲzrPKm1PK.<org/json/JSONException.classuPNPG-y&n1nP	dZR[4(imDl{z3gϯؕ!,j
1'Őscps"װ˳cgHlM‡A+J9-]_;=?4,;"Bc9w[XϾ"}v`Xb
gK͵#}MR^Ƿl,3?,]Of֣ku|42	l+h`Gܵ-mPXzGɘҝ:5ŕ|άG+Aq$hɠKKA;J3K>ql>GEU
!3jDZ#U<
AQgD%oPKQ:eKPK.<org/json/JSONString.class;o>#NvvvF|`̼tF
MIJDļt}5#Wp~iQr[fN*#?BH-#p~Q~Vq~>YRK@b`LlPK'xPK.<org/json/Test.class|	x[Ze]($\}$rS88;"l+Ƅ%whZR(URRRZRJZzJ@7O/9}%ݙٙy/yb0`eLCX&DL-BV	Va`
ڨ\$*J^e먽^
T@=6JItMv8c3=('Pm$N'I'XDS$8
tK2&*AI'Nz a	&鑒@#ir	vI!;YT"ll.u%-U%4kkglXӭXz.	HpFOK#EA-o5G`/d3%8K%<	|$8W$8_$PbDKyE\F%B+g _\%ՄX|ɺU=rIsuQy_+@7&;*_#T_'7qIp;IoIm	;M{]	{I_|_$_$xP$&5y6KC	GzDG|L%OI}hf5~n%=K/%xFg'/ר@-|QHw,+UI!$3Bs$oJB%T»=%| %P#	>ڃO%lm:q.2[Zxn+$njT:%-qFħH|&8>CGQ?[X~7	?FRCL$~/Y-qī$>
|.0k8`eUsNfib*0w{<&Lҝ@%S޾S٭J7idF4h6>M
8:4`6j NSf8QѥF
wLjN]K	s|(x:R)5ӒPt]ՁnUI
ZN5j`^|{mMݎ|t_ל(CDQg;9b^KgnoYռ/WZ"ZJzd%ӊabS1YT鄪=ZFkhĚ;"֛2lnd{z#Ȳ/qo6elp"ݚ֫8x7aclDR\
c@se0	wG|&PKSmr`eqDCv^rÎh~@^A;=gh<)%63錚>ňdwT^E7jdǣ
ٛQcq5eJR˦&bEm}	dSW[ԛQ8VwN1P%E6c\``iMK"JbȺ
ұj:DB!eCUQk25ᠠɓMᚡ:i-ۗnvy n'4/ 6*US[S
LMKDE;0!DUꪘ'w+(lLH\A8!-R>Epj%ˢ֏t[蠩O>lN
o+
?±n9C
P*0Y&Tp:bVMad'a&Uc@E݂
dDL[:ECjf7-SɦqiltGUlF#=jĨKe$i#.f4~]}c3p|t:x(ToQJQP\O*D0hyhIh^$D3>fSFjfB*5
Kn3)5hHАwXG]S(]5^
E3Ap7:4?$lqT]Y]}'{0Q/oO@.oQ9>džq;F:
[[e]MC<ƴRz!U:W7|>]OyCGAM4V4-j*TWGӃ+%fvòdqBF3877"-'e1zVzl.XNS3֓kgVh.|;Y0?uM` !&$L||*iujy6	52!t
GPc$Y&	{	'b!70:HJ@‹m&<ZlӺީ)O$J:,TqpL&ld	'#8j0+
FcTCO{1$r!)|50AFkh6iRڈ3#\uWVME^LMIDT`6TK^-o[.܃QA#g>7%1F_$%_Qp]h[	Ca]Ũ"O#3d	cc_jWAYl:eGfbKͩG)-_@_4=܍FеhZdWV12z..-j\
cI%FQ?*SXD-"8Gduk1#zT5+VzD;U	U2qbFP,G4gRIעH ֣*4rq^J3㍩jK#arsn5M攖+]j).2Q&(ҧљp)h\W#	AgδL!E"0ClȯFnN|x1CQy$J)<4UE6

Gs^pP`qCMF"M8((LP0	kx&nE&NQ
j*%v+2n4H3CPMKWMH0&j;OxS&
F"6ΦKiYM
ίkc<	FT@[Ke>P׋زKʫ6QѨ6B]{=|uz;n(vB=m6з`&r0ݩXMRNkxMk8ْhu0&b:Fܼ4x7
RSYݾ	^.CrvZ
zPS WΡ<)i5@pBZ
ɔղFS݂Tv9f#.4Õl-N!ڗM1{>گc1H&b(@Bbռ,N#]Ftz6?֡ώ
HhmO4'tЏq)*:.nZ.c
:˅
ioZY]\߼u݉n5axSzo-ޝ ZהpaT	A_/"%K)USSIEՑ^C`(r-6	PLëoBT:?"|L*4瓋i%2K<"]I̔ 
*JV_ump횄?O󇃻DYh4""Q4`Ay/Q
TjbK?CfXɦ䦈Fdct顗R:ݔjЯӵ^'u2ndT!dtJ.ЋGzM.CxBEwzdZ*bIĻ?M偾.
`U螌f0)R0s۷S.{ǎF9Қok?4opܘN5͛7QL&C5.׮ZyՌmjooibܙesi`SqdF%tZhEr:T;(15$*ZS-zF\>z;.҆"1ʠ\xfKuzC
;LXrX}CG%BHhↅ(zXȧ BE
/hтŵ4r1JiF%mȖfX)b
լaDڱ=>c'sDn΅7vZԨ[}TFϳtJLcMc:Dϴj?dv%&	
-Lb,ڕLOthDw&1ϥ2h)Bh;c?A{NFJ2X|AIݔ
Gń7}rR%4Gw(E7ֳ_~RK6QDJ1mRq!1c1n(ZMBhV5/>ᝐ9A.Se;iMx[Zs
oΤHq4fJT6$jhTl4q{w+J_W(ao;-JB|BTD>y\EKh'68ڃ|hW+ף^[Pom	౎i)ڇ7>%l0h_\H/0ݸj)HGQRjcn;NSF^ G"~%)Ӌ/~U,Dw4\ZvxQ//Sv
`p&ۇKh^gG+ˣ[d5Bc>ٔҏkO*)B|!p6j"K`>]nIY݀vQ$(ZԪ9f1DG\4(xƦ~{=%>k$m,ѣ}NNB	*hF5_^VrJU=f|9NL%{W_uE
ꈵȴq.y—&iG|w+	beNU-ݧU푰_#	#%JCVNZ30ӫMZ1Г|;:MqP);pFڴ24kڄYҹC0s'9%ͪӸK*$򌊧Khi<%$<m`Vg)4cdkRR65Q-=2F)]dn&sʥ
Bqc1c
4f|v"owҦV?XWi#eyff߮&Y5kxQJXZd3nE63rq*3jW18\8œ:'Yǥ:ZI8̚0+l,oH5WbBАfXпq:a|~wcxg(`0f3r<3[6Y,5dBuu?踇9VcyXz]{s3
~?;l~]j96us{T;-Ǧo3B˜HY}5h0!16{hN#屓N3}b1q&8p_$2yp]BB1+~%jlspU,3,96ϋ{WɱjuTZc-B".F`-ɱ3lXj
YqVS04Dz
P/u/ղ3,8ͅbYےc+Z5̱j	R}
rl-۱n;Du9Z'|K^QkN,ȴ
Bm'ۊl{͊)1/&WwP3l#$8wMȻskõ˨k|,w]OUכᶸn/ܵ,W;'bw:/q_;aK|c8==XxXs-wz^yKN_>fl
[ǎa뙟m`A-`l)b؉݌-l;TiX`;^v2;.aknd1v3Rzؽ=أl'{X’/,a',fea*
Dzk`theg@ٙ1v6d@av.cE]W&v	.{p]+)Ea:v<>b~~.{_WMa~!=Ÿa?⯲7OG2{/~Zv{l&{=Ul{l%EY;eFL6lž+eϗiWeYBٙŲKeߖ~W {jeb#Ga92r{`[m	쟖KkgY_3+ؿ-ױ-_e>>`X~>I-CMX
e`+	RR(a,G)Ux߇?U)V/L	GXg4k5L.epum]X7ñnu'̴g5x^ef[KPeX>ǡ:Po4X߃֏a\6dh͆l!ؖ2jhurhj뇕ݰv&klZ۵n:l߄peh:%+tI$MұSR$FHII -m]R7RYitIWiM0,{{+ΒpN
;[*+f5pQ|"V,*peEP/V솫+΄k*./U\	V|\mJᆊM/-v|[6{=a7[m{_ٟ߱ﰿT$"xvxʇ'ã/O+_'*OV?s	pu9G+~§Ht~ǏuGWˮjǹ:l~k#ƫ\Q>tp
j>^:׸.Aוu=op]w{"׃|	v=Cyz/uɗ\fx[n+S*Ѽ=uu^;M|{%?ɻ'-}*4wouK+)⾙Gwx}WyawtēyUpk.xø'7vL6Ar~ũHc3=c+=N,>lG=b*=g˱U0i2Yp^d`  %/PK&/m'PPK.<org/json/JSONObject$Null.classmPN@}k;r!2!EBA,ۡ
B&lo{3`[I((&CQCIEE:CNx WkJۻín`%&f'Wkh4]`had|vŐy{nGzZCm`CsoFX$_v6f9؋nP'σxpHx}HQH><1l$iitB[^$Ia(8CO`XӲtx҇
$SGԄ>wu313%LZfMgH/
ow,8"CtS`ԨaEJT:>p"}bt:GR(YfǚL9^}
E] p|֘v
HX8nZ"7T0Ji*YhA?68x]ڪ!.F4-Ri?hMaK1N0zxӉ
Wј1Tx}HMyƴвYӚY`bOA*
pdZ^NX"&d[7MW3V\h%ʠ.u嚶Ֆqp8ul
jʝԠa!bgm;"{U2RҘf[.wMpy#Y
sh"!kfnm[ʓ!;Ba(IE
ǨA3۵uQsJbH%DZI3wNޚƫv_DhZj0{̤?%Ӄ1y?zH/~vx
nQqP@G}.b
+<2qdDGG!a$n J d1z'PK/UPA{PK.<org/json/JSONObject.classZ	`|!%KY@p	3He%@4dcAQ^IU+)Vh=WJkk[Ooo7e#yͻ xST
)3P#4nN7n]b]b	K9whK,w++ٙf!2Q "40G\8O4ZsQC0C+7mQDvYgލv
_'jFޕlr؍rs7J3G\T]k\z'ot\Gٍ
q㼕[\6ݍZc?qtcKɘ/.|̃-<x톸7t但
ݍs\xs73?.sGݣp^5?x87Op$7O{nnvr-b6
`KZ3.,ty+|?>o&E>|b/iqW%~xÍ[VK߻[.x%bvZ-C^+q>7rK{|nH>#8]4'K|/^!cyXk/m-sK}GK|Ǜr	n}vHiH!57^!4 `V67GZg7"mZM{ScmE Xcp^^\U%ͫ.Xun.FkΩ͍鴹t0HMUEUM4,{n[y켅jl\kml^=d-Σn|C_R,&n,uXc.-M}nңGOKb;Q;uukۛ14@iO#>ni4[E-DLœG'F#0,>+m2fQJ0ͱ~*Io85!	
x ,{EcoMϠUQaivpDMx-D ŽN)SHCfZKX0\Ya:,΋l}2i
ǢlMձ5DzuAOba͖Fiv?tF[hڄ&姹2JWt@s.ҥtJ2ebgK0c3!}2l({'OcHӐYďR4,#prD(Ύ65,~u=݉s?y^ܟ4בn8yjQ8xhmE+jSG,.	7=H[>67H;2c>j	z\9䖦Uʴ1Y"(٘.JsvA+c@|0{OctRI|!) Lk3h{k]:Wcx^85ܶ)|8d K["#sJf{c1UducLLDxǔy2S4S1o=z?|?@71[u(B4H9ؔ"SbFP\Gm]<ΖCb)FK)FSC)009ܐ#L|CR!f'ʁVfF_B
#OZNpZ Uf76GZɆzėr$q,c9#n$cQԔe)a3+.6e@8Sp^1ДedcIF{moCW&cXS<MmSN x9΋
C$a)'I,O bAȉLID"<ƃgSxb[)SN$\&Qt149ݔ'"ΐIPbLd#Yz81ؤY{+)gY$͜ecQ"/g?rr c29D41XX$Mqb01pb(1\YaS䩦R\4<1АMY%MYV**瘑0Wͱk4Z O3S.LXL#	,?ڕr\J 䦖e,gE}u2f$"ioijγa$mè?ؾ+d*ţ74pCBrGRѿsHda$5--JV}4bkHSS55غFg2n3Lv`dJr&SLdH2NU2T
ȫo2N#5Y_UT,#;3f-Shl[iW:wp>
-Lxn檊^ll^GIxi>}[/4}EqWHT1SstӅNfIN/EkZpv(+ʻ^6Bխm$E	|p'lE
 ?*h܎RMFЧqp!!kx
cwR; [Vd6]{%?`ӋC{8*.8`,\!?EEd1`Po{i~~<?{ZNhW]jqfj>$dDX@jaSBgf^w2iE?3)X&e߀.dX{<Ӷ` 
=Q)+9)Pf0uDc=umXeD0JP8]Ѝ\]arC'Ё4rx?
jOB+J&	](t`7K\~$24_cR|	%iy=P?CĦ7pZ(JQn
Mx!rԾ1Y;'T\㘬i%.;/HȺ%tP:k1j81
eTIT&Λյ>%7}	͙4G5BeIMS"
{ޫyQL$A8m!xXKC;1"@wt֔@0J:%$.Rb@L-f'.
M
m2I
H|TL%bđL$!NbPqzJlOpP1S
|WHZpX4tzse[+HbA81źWn 5?|7FF^fWPCMvcܾYG{F
&VcXrq.n8c^0i9#wb|'M{MyIwcV8)䙫B]8ސ=QI{>y|vP/'7 G\D}1ƋKKQ).rW)IqHr'$\Iaաyvb
pj/eq[o'5:qe,ܙuiա1'w"tyrh?fxgvaVhyseHKr #pJă%"<a'EHiV
gPс,"lW;qj*鏴y}Ha	dD^RggiX
Jr1I]fS7;
umQWPUvd^#ޠ{[ɤUT蟴I[m}R4`T?bƤEćDG9o	=:{t7t!:S?`NKt)MKO`dClu
EWvB;hpfpeyZ<}PE֏zA\%dtYy29yr*G`,D9JQe`Rd"+&n"lwC{+"r1YӋ!ϧYNR9(r9]QYK3CC4-D0m%]Vw$"3z9/I-Znodl]D$Ke5iggZΤw5iUm('؏.,α<+.EKhae|a%.MhZ ,as
JR]uiCdJ!Wȕ
(Q&Q!E<g&4ȵ 萭YpF.A|Cؗ`|!'RwlwP%V63|"v~*iW7
7M
(!B"φo!XHĥJS܌r|DN`/$]pɻ%7#_n6OvA21VGT3LQrᤊT*G|$G|$*2`<;L5ɸ^$S 0Evc܅ix-$}EቶePɲ-Q\NUX	b+:pnd`;4V|C5E)DF
@L*ػ
QDYwhB)'h1J5+?FrQEh~R pP;pU;ĜVvС"8Ւ/G_/(8D~)9Pͱ-&vk*9XBf!z$	D;PV PX\Xa™MFZN"<Nrt|~SOGGr40gE+ƺО1]bCϴ2Ю\s6as[/-tUBF-r讦d04^aP>j';}7ąx
o3?¦E]Y4F!3hå<̣*LIXs^w\>EmaϥYp(mbZ
bqU.`s2z_GԳ0FDfB
_:x7`&q܌I[0q+Nq܆۱c4:~G'6:pc3tl{q/^t܇+υt<"7ǔ&!0<G6Ĩ#TuQR2D*:9c˾FѬ#-v'b#ThmSUcIO@^urq7"z~;/E0!g{>ԍkyqSp%p8++kKqmZo?ڢn\G`
X^iq|A8L1.5̏i8/(klyFU?O3+}S_9`-G
BCVVdODד8<:)<&өz>9iQ;{8DZmevm]BC6Qtc[II\?J\g@P;A^>̌N;3n+2
='݋BϘ.m\B[I8zo]܂|NK.vGu@!TB*D佔ĩ;ؗq++nD6%DxvR#{GTokAv/ȥI`ŧBOYnާ89=x\4!><#~hύ}b>))2tĺp3}rW`~*z%R"-@~q~f}	:JvO˰G_~6S=?G[]2PP~j PaZR/pړ"d>
(_/r;хȹtKޅUۑUn]Wp?f$?m%t㹜z$$;ƹ9tRd=CZޫ}<_͖~U<l
gYk@LK`ꗒ^|J2k0\|5k1Q'7`~?"۰I1.z:N<߉'O߬8)I~f}yjyyy)̞e3U{2ۗ`vM2/5iهu5g%<+}ܯΉ381gq6}?A,~XM,I,E>i8}NdYT|9?V	1e\WqdOo/jURtx


x<[̱mv;mQ권҉l->B^#ۡ{c!ﯻYܺn$
V~
.TFܠE[@"{7!
b,
gXQslԿ$q|op~\a#ֿN?8xש=n=oqz;R(Vԓ*)M%i;7*jQMг)cI?F9r- Gߨࠩu2)*
&Cvɝքg;4O+1|GGH
l:zݻp_(ǣ;Z7t7M7_JnZZian5ݗnQnFB	jv#G\CIcc{3.3;Xa;*hSoODPof38L7$݉.
M84Zj@Bb?	\lN@#3to4wKh
{E.'w~]ʹ~Wd
~K8,4D\(RJVVO"-sNiK5UqnK-Ų.0/}[ɕJl4KVjUBL::! PYi*Fhv%^\.9Te/L	-O?v'WPE؆
T0|>B^*-t9*Y+.DTT>Պ',0a\8ZJDV|wH*zpUȨ{c'91>-QH-M*k^W+?`^Blӎr[$ĊX$c,e	y]2PK
h<P(junit/extensions/ActiveTestSuite$1.classSMo@}q8$-Q@ip!uښ8*JHMŵ%J
pG!ZPD$lyfvΌ@0H[2JTpVwmཱྀ[yx.r/0z*PVHƩO\ԛJl1xPD|xSǩH~s >s"c)Px|^hԬ‘럸ιRW@|2:8XiWe.i4G
N]"agd2	&v`↉eMT`egb&b$PWi
Μ$XO-N<_]s0"1\YU+rv#-~59J<
7wg({3hzH4MR3|PS_G+w+FKPQ {?.3\5dLkX"uh3#Zk;yf
2 ޥ7xgNPK
h<`ǫ&junit/extensions/ActiveTestSuite.classUmSU=7	,,+	DZk-j
PKt񋟙03zeIB0g}ssxd#zT/ \[eւ6p듊X/-|eaU TSs)C@^iF_|O-
$ӏRHW=_E϶dn5x2Zmc7s|Ru/V݋R/C釥6F)Y+TnJ
ò&PuiF8NӾ?v^U3T7E"
nxsgf;c6T<3@̭9GAQA\-|$è_`ly
X11	ӕ۬Skp>úܦ3˜p^h_58yvь\Ќusp	cz˔^;_4 Lefk<Ԁ;핿V`Wi
	
AÏ)=YEJ~Sy;
L󕁮}]|ZY>}̝%F_F96w0 Ői9Nxmx]g,cr!w#h]\&ҕ>uըXb'K[8Y&3)rb?RaUyT+4`cK֖MtN<OYhf_h&*w\CT$}{X2f_U֚u_(VwZFؚ5RZ%Mj}x0vs0xC3xW-A`.Փ6]G[\]\P%#Ia8
*W0!s3W7ܖ㦂E }@4D!`_wt}d"'wK Idj,y9\SM|:5R7t|>VҩQL?NEMhMJ愧u-ٰ<8DC{"ب9M-4i⑃0l_m_&	J:&1?)vzX`tSw)nAk();Dv(}uu)nu"4hlTiju:f5~Gipr	s>^
`*7|*"	x
×g/r.b~M8Вwp겚.d\Q1
54VcI50.i[bZ`[{z*症bxGuuPK
h$͌T'=͎=DV >#©u'bhqI?(ywtN~Ĕ>72sI5+~](,%֧Qj6ݸY.b&^-mDW`J7U*CtP}H*yH2.Y
`ר8CRSnQ>GZTgq>exTX$f邠x~PK
h!Zhӳ	2RZ	KVG7B9Es}z[*G)	Oo
9v<#kw =(uZFQ~{J]Wyi?Zپˉ(iL]"2`˸ř.ͧ-ҁ}`+Y8
dw~Wy_MњIfob; *F/PK
h<γ)o	junit/framework/Assert.classixTg,wr3	bBI$4BKL^
қ&t27@pmZEZ֥ԅ
֭u~O.;3;8aN^|HŇ5#a
>A'Uahhin|^<ʵT|AC3ȍ/x\Op*Or)_հOs|M5p܃opM{kgy9|?w]yAƃ{у.YʪI
UVt̙cyXn$o^]oj{8jŬXS"+l[
|wۏڸNL(^A]^܊/@alu?h;G֘O$OY?+^øƸW%:ty}~*.zc`M=lbK,9ɒ?aaL=R?cTƆt{~#)a<4`]no^O`ofB5QF͍
SƜ57/[[/~{G9s0h@g/n|Il>nbf,&w{>&+ͽ9jչ'HɭUnv݄sx2-RM'@ry$_,`*ıD7#U
YfnRXn2Hj]iCeYhsTY0}5*ARxO5%nJh:
5jw)Y=XQ%A	
cTQasJc%N&ؐU.41*B,[bҧPZi1m1wR Q\茵c]"*Σl]\t)Ȇd/Fhg%`;FXdW"<	>BP{G#DtRLjivQ`vS{Rf{p j^IHT%ԞA3^[b
eB-+o{R&/DcOΣrY7:Z- /c-ű"OƇ'~2>$=p>dÓ!ۓ!ɤTvU*CmO|[p.
e?yh[Z.T,rnҩKSwvVYBDqp)DwCje=ghx+́jEB^*bkbk;R.8b`Kkі_{veu\RA2 I:=R g3H8A9 T+8wKAe;Jp}/9l%ArQЩu獂CJ܄!}{7iKU=wM5!u6Ghb5tn!8vgz%L'Ay-_,WB}#CfkNe8,Nq!GQf=`ylsT
6m$5&g*+F!$UQ5UQATPiW@=bRm>z!JenȾv{W7RVIYsg{a_^aۆj9	@j%ܡԁۋ3]
=BCF2"BDy*!IXs'H1rSv1
{Ҵ{Y";-Ӏc/+'ZC4xmWx ʛvkn.@Lc_=#=}e<i}LqIfdtC%#:ZVC7҅7-:g	3;apsZOv^ֱ];D4"(.`?E	wjҟPŁ32.:I¡CdmYK1,A :9IqA']X;pE4L|*
E(MD.;㯐l
D$?t_>
Szb۴#b6"Gu{!\].Pk%{O\j/|/u#^D	uh*
\%>Mݚ'ۻ[&y8-}e%pJFt3±#! g)CnwͱEk憕0|M)_6sG$y9TTq7R^PS4]$Ϝ7Z3'^&KѼ{JU&))PK
h<5.T'junit/framework/ComparisonFailure.classRmoA~\B(Zh{ߌƄ ~jǂWٻS&$Qƹ3?}`Rx6塊0lVEŦ-A٪KϰTs@)m!	i~[Hv7	*я1OgE27Nn3}i;'jj3$ڎ?cx\^%Rn3(5#
`p"dE(ZT'j1I]+ߛ5wpFPu+=-IOI>^	+"ed
%찪ŒvLG:X֑2#]Lv*4ј}{dϙS8RiRQ͆F7EoKMhXN^K_CzgOWٹhW,P\=cT`b_"
Zy	kIc>HV3MYd!+YwɊSn~XL!j;qN0H~y"HNr4IB,&W"'&sɱi\r1BPK
h<BO{'junit/framework/JUnit4TestAdapter.classVi[W~&YjR,E(j!0fĭ}]l}jlO?3B?]===wl(Q*WrHF0&Q8.OURHL%bk!UrpF!=pZgTsbxPCb~8Gh|㼊'T<)OxFų
Nꮫ~J'uk,.I;TcCX'Yсe>O[w$-b[Ogu	휈=}0kDOy#9LɓNjn*0P=B}e'
gHNRg'a1> q^)5kZhMM6X&"(yp΢
RUN[tFw
:SˑR0spIOW8r`l
"cTBM;iLLW
Ew ujWdwn1SiU,(XQ}cLا1vMKNI&NA6{dzSݳEmVnVRz13=95&.Rn|f7܄ntRx(cXDwIWstѵop庴@J0h/Q} y
/E
m&4UÍXe
U
u
͈xCÛء-h
{OAܩ"z5'*>>VOlI`TO195QT+,=pS?0|H0
]B$Jga}v~[cB7lIQz!KBQ]v3َcnɴVCBt#7n
yAۊ<]EIH\n9.-ֶ/jGD]}xg$9kX K'$фIm4qC+>#qTw6:(X<2e{4in:G[vhg"d6P3h9oN~S-h\w3 v%7ӻŏHy47tAϨͧw]7XMQ,k|J	"Q<,k=JҁEM
KKϻ
!7`
֢%Cz_{6dkE
xne+c-?Cܔc#Ǩ)zT-Pts9%(^C(r
a""S渌n-'
TF)XdXX!V7{LcGaf΂'	*/KBHm>N$?U:!/ Y ?QM#X5)͸
]Ar*5ID-WLk1M|o'xbX|M9 i IcC0ʏSU_:\src5ɪ1Bm{+g?
{V?JK9e,Rp빨W;b!jng"*[ŢҿNYf9<櫍a@0w3=6l}/LzYmd&kOG
++
TR%,jBUՓ,vu`>+ZC8$+O<@3\!&CwWxhq^)sPK
h<.junit/framework/JUnit4TestAdapterCache$1.classTkS@=ۖB䡂hD<t*}i6&I?Qw
s{w4:"%Nkc+]F3
fePOpW|Q6}q{w_2Cߧk?%!1&Yflt_}ȺcX޴v@{"KW)pk׌4MYsܴ.qy-U[Yz3W9dĉ4z
(@2镄0@Cx0lqm`x~?v]Pw[9Sfpq^&)2dx],c(x=5ȷh|bEJ`V5*iqrNM-;g
v*KOT(2P֛L\T>ZPǣaya8q$.e4n`Xi3R'Qc2S5G}9޵wq *k|,5ghl؞r$PcBlig2P.Hoz@ungcp:&y[GX:,"nb\xNI>2nঅ[gc-3KzL	-PᕰRYxX'ӧɺ2q/ZzLUc5V6וXB%v>{ᷣBlo.%I	,TǺಫZ_.]]R^[}r;fg3+Ue*OKoPb8Q'EB9]_p{ݬ,ӟM9:z}?+հ]WԊ+Lb⳨@ʴplpmg	Y(/A
D-	+
p$P/ѬrSDAт~ӬҭaˊEֶEDn,>Po(}.B?ꉻ{h,4=z
'rF$Cea-k[B21m[B틨lA}TEy`
 ŕ8Hhp@wnOy(ei#k38@AB@g-D-vl	u5'E4@Y}<9uxgnf),#\B7WӿT5Uc}.;C#ik"yɧʝEVvH/ӵ_o Z:dyYkf 稧Y5e'J1ȋdhhf{Eui[EWj?~M
_PK
h}A{|,AR:S{I1ʕF;=s%|r}CCbZI
@,p	fL\_zVE
.:T(KQ~%pJ>d}y7T#?Na>2LpkQNT?Ug*ieW=Rl9‚)q-J)2#g(#g$BU
PK
h<2̏ݘ!junit/framework/Protectable.class;o>CvNv.FFf
0F.׊Ԃbvn ?8(9-3'A 81)'U/+,A:4/D?(17<([I	PH~Nb^RaPHFQ~9H!##0]y 
فl&PK
h<>V9junit/framework/Test.classmM;
@cb"mҸX[
 *ĸ,<w{0
`q,ENԽSƮaCֳv0/vS-M恍<ct͛cBE+07$LC*:b_\ۄ@1u;4PK
h<<99
junit/framework/TestCase.classVYsUn24}%L2	@$kgI:icw.I}qRJ@I	>XZo,iʇ99|}ຊ:]
D>t~9: 9pG𨊅xE*t()UQ%/)lĐ
+|Xk*ÑSQ+'PHคeBI+xC ס3jq=cLU̼mL5ؽ5FGXt=ltkr.Ƽ,$	tע
J7[NMم7&~	h9=c,O`q`V*BqB^zܾN!6ݡO)jdLH+E@vg!7nxvoA"賌i'RKw
XHͲ~ښ[,TM7S>q{vJ !c 3%)3JWA)HNaʬ}vthU
.j
>.ӡ;`^p2s3H4\UH
0$0v 0w.0tk}f9G+7ӯ%^N} Tli|cJӏ$n@6k^
UƮʖ2ƧL.T>ݴd'fڽfi8 wS,p̕!r>5>vʄsSϴ|熺=G9Ĺ\ߒKA_|j'sv9g.ثw OY2l!nTc?Vp|WHBԪeHIV?	ɟ%v3ªWrET1YB͕PybJiG/G6GQUrqh!V
6`?l9DJVy_}ZTEXϑ
%p^,z ޔlfw+چŲҿ#~p.Z[sQL'a^V	bD%

*)P5Gu_1u{a6ͨ9Yr]l6ss%b'-'\c/X8E䣽iK$a]w2aÑO42}LO)e>|_S6oq7{rtL%nvdտgV"TqN8_`s;ow ^b}2BlwxCS%duK> 4Vd>*
"LXR忊JFBo3A/:{PK
h<0q2Q8!junit/framework/TestFailure.classU[SPN[6Fʵ""^[(UB9`m4gK>茔qWn#r?~0u=JnqS-1L)V3	}[k1wWpOEhX
)xaVVQSNloe)}F\|m[{Յ%VU[1Q.Nc"	5bN`<})omInVrЭQyi&1YM¢6K9*z2i>îP	Zsl-ȳr6岴!Lc%\m:"L{vbNhu-Z&Y[!d_Q?֬]&HƙTC?j8szGՄO90+[֠cI 2=e+VՐC3Y@U\s
#a
E
/@2P>
	66U3B!bhCJHt$PSj@kz?Z]Y$nƴgdO<\hqm!7X59@^+YdDY
Whz4I7iΣR9㔬T l-n!QNLLp^G8aߑ34PK
h2xXE3Dq\V{IxGb!aEc%alveتsj!WWgmR$ݖM
	yP>Oi`pI)t=Q$Ab%#KbS/U>Qq~	ٓ~@^싸,,;bŁQ8pP9XEz7LCB./jNcyQOa~@u-BD2̼8OPtK="/\ӟS-dES,@*51m͒u0o7?SGVCtQL8&ɾ#(=nx_"gԒD
e!)c*Ŧ14QYxPK
hK"ahӎ
.'rEFWq
ψc7!Yd-=y]	%,^*+gU|OeH.UpR/˰잿_ֳhf狶3p_Aa{rBTtK_5%v|)V',l:QFɐm^p
g*%YueVAKa)_IEޞRM8 6SΓm|d,TV֒~J|9gu(s1/î↸ϻ(Kl2ҊU".Cϭ(H∂:;eً9<7\5=zrXS
ӶmXN\gkUN)W/q38aF~G,$Jؚ1T]]ڌ-v}Q/o?0r丹4m5S{TYgD/0M|BPQRR0NwFhͤb}
n9p*;F+N5rC+xhV(F>
=Нf{\1^ɬ6-NjOK#b%3lP1y{\rɢBgDxPAw5Ӗ_Lp)
c"b\!|Rmb$*0S
j	n?a.4L`R	Sy>T\/K
iY82l3Κޯ4<]Ś_#;n6l:bI"kΔ*c.07X5гFr설DNv][WY+`\**F#6M33eAoNk8Zm75l3
R^w-[St%oF?H[zD1o$Zaƥ9`L|f5YV|vqHgS |?"VT)
UD)!wSO?:1xaڇ0w5O>|7iQS?ږӣ@{]
2PXt*+vң+ʦ<t8(&S8b'q/Ӵ}V2g\Sq"KaLBft̲dvc2s
xL[êބ yVzgl
k8AmF=A{OzQ5|qMS{|8vaMDVA	}7*W fFnl!C#DW2$2\.)7D(1K%~C,)KHoW=IxGŸA5}P&P&_	e$$
}&E{Su}˩mJG׽}`xdy`8{= {/QI'I|H|5p@֧BjjT%4TT:{ְk!7KE=>IQ$iKѳs\{q7/K̯W\FS<9'"8s׎b(p@Fx-NU9
Z'=WE5$2>#{Fuiax7)≷wh
ܻɛA<PߒhD.^4z gV,.ݤ+-ƃ?eDl;~;
H`m
,,2d[
m0Y{^vj끖}QMK!TUYZTmAZ&CFh~,aZnd6(T͘
{bXXX.HۭPutj>H4t+R\>2T"{4C'ҙ{n3f,gʷɃX6\Nof
b82G3GxHR듎ǒc|ۓ.||zM7gstJhnv8P*rs3qẹIn%=IccfM_44Œ{q3usӦ6B}(tJ;:T@a ܶPXzFtDT@Se55LpЭrt^VcBO.R)p"IQfb5(chz xڥf5>I	""<$rfF|i{5/}¦hr( HП
΃	S<7qO[w҉e&=@~3VhX&^(iH*Y3cN	u5оT2_A–+cQϭe49l6yStT|@TlDs9rwzƮwt/zy[\xdl+tx!T+аc5BFΩ\a2}ICL1+Vjjl
	ʗɧXq擖U=VX%$?h;0N
d"Wh-	Djʼ`_Kʜtٗψ¼mez`)5wURA3iΘ)iv3A];pG.u!e'%n!,?ai:N}Ldcf^ܛ8Ƶt8bix.FBcy&\@UtA>,BP}$v>
c5=Ϣvm=AmG]K1Y}za>Zg IW.`r-cLZOOM+QIB3|0I|"qf7z܊=3D.^rهwpS	-8J.Xc&kF9z=:9w7ez9JrfBУYR&7#Cbd3}N'TyYM$-M%J'MnZsj8JɈd1j83NMh:E)oqgFĹ??g
⼅-䌈Sv2.zSLKoZL!l&c=a<6Nv(ز2M{N.NR>bx v2QW[Ilז:Lyۣ1Y:Χ=dY)3rK0N+Lv˪2Q%l}.>@8m2(CVir(x]hAWY:X@in=ޓI|e1yl#?;氓-*}*Gsj{_ v>X/}F/}
LMWD9#OA,ҳ?e
PGd;hCQי&^}>Ⱦvwx	9^:*H$G 7oд3Mjr}Mc;zvV|G1;<&-;?a	?XV|@t[K쐮]&WTnbAii['m}/;EoѩQO}tOddޅN9	V>bm
2>?\GG\wȳS.pܡUrgZX>ns
#-f-fiOibWA(ݥU@U:7\{`qweu*늮"ݛV0_wΝoh	ɠFH7
s\::ʉ)4>T{ގM[6vl?;kIĒ-Q;O`ڐJfXKd-&GV0:gv<Ѳ#v\#vdbV0ql'l+cIoO )2۫C|R}:=:twleSĮX:.>Rsf%M&tX2N
*`Pږ%Kܟ
ZGSC-B	I7ӤeyCyCURN(9:#x1WNĎXE)\g:8CYqb8dl:k
qD>/Riahb'凬L#N5+MmJSixatꨄHdws,Ȧ!nE9d[ŔёPG%->haW!T}BcȳÄ%G:AC8{	X{4ېe2){s*ˇ~E#3VҖ<X
kK$Xb]/1SH4)ۖwޙ+nW:,@/E:9{+

XO-25V"6ֺWF/ӀB	n8Sbۺ@vJ)<4ǁx@wtnr3&
&pɀDfQ[_?Lv^E}I|E/П|#0黲z HOxBUu>d}7̀<:LV^.UR+[Z*l1}jƷ|;߁qMmf3v~~%(ڵ 
?wJxeAnCf;ߓo'v2|
Rq+ux!x'Gy;K3:sQf|R _YH99·Kp..9<_U`;˟9Z9LApi:O#RUM΁V"O6W:0ml-m9Z$zP,/`zLӐuyjepLP2rYID7 {d&~`]FqH+A1^J0d4eɦJGc@zw3uD

W@WoCh.~	|d4[P_3xB_yW=4GYTȧUG搀l?O아܊v}#_w~Utܻҕ]=
*/o.͇{;Wω<YlъHa"KԒQ~VrYYVD
HHʳ.>Gn+a@!Oo=4j+MRhU2SӀ7s4!LׅrލN+{[x$74NJ@x߸ɫ]
gy3\,rD]^.Έ7hIDsŷ/G[G"NR:
$KAVQAOa9QYj+{BZ<>N.k	tlwq{T4~j_ƻb3'?zw^J7dKynr:[u0Qx3%L_L}7S̠>JҔ{_W~?pr4-׳SԵ	uvċ`RY
e'^`u:}v*o5KovSu{;Ψtp0x+o1	~ʗASWpg@~bK?T	
b'g}_'Rש۞HOuw/eC蘵Y94J#9APEA]
`Dk{
x4ouNWBb:B.?ѿET5OnYr][xG~DӾ0a
y4^遣7nG:i
5::\E^5WeEl~SP/,질N9@tujc~v4QNb=y,:Oq2G{Z:(:/'zh\{)S`S
UTi3JEkx6mzΗPϥ.vг|^0\euVV7 ~)l_X*NIڿDB/抳TA-x"|5dsawk֟dOy0=hO hLGў@0<m/_5[Zܴpd6ч;}[
	#-*^Fy9m62_bKwČve f#y`huM¯6g{LΠ]Oi;SZPK
h+=uzrC>y!/v;{$MOQ\mMg9	'NwqQk $GVJHQ>P.eܲZsx[&DV[tahv0Ss?ig4op-^>MvrPK
hLiM+uƅGoKܹ{ӯOӠb!d>ӵe,F#v^Ct):Ԙ/d=lԢq.PaV4$)לT{G&PVZri{h;ߴ)ݙ59)jD;+C븴aeu?l`vkx
Zlj(W\ӳ5sS;4O8V鴌SEgU.A~qphc8`i4nΙFkXJ(5o򛆮pPFT2nҰWAj-fp*J;J%V֜[i[-:QX4[^2;kԦnNNӰ.\*יUq[z{¼bXᖚn-W.G-_qJϕ2׭dZPk{|qfa[:a-j`/؏8 dF,;ޱݛ89,{ɭ;2Qޟ0=|@Q,SK4p73Y,GJX3
R_?s-./
/5~aer//^T	~grr
-yr\k(kX9( Øcd&1TUTx[E
N_NA3V3o))C=WEJha2+*Rtٮ%1SgqgLn4SH=)'\r	r3m!ćͨ㣎J=ؼHs}är³|DHAplq^''eQMATwn-A":vC]rXwS:Og^9/ylq x0ЎpH< ". >'xRO ~^ؿ 3<+'_s:ė:!01OVZΝdn=v6޴dsڪkkk9}kGC̶T2cI{ZZ[wzGgߦvE'{m{;6tw4Wy
5xR1KCeg#v1sY3to\t3d,7bf3y
uD;Jf
5pFz QB"! H!LԈAow	{x]qD;2lC):'XTR'.G->le2 ef,Xy=l:jKWNrL
|
n
^l4Vֻ	#%TzCÜTP)ax4MPeAȿ[J`:+d
QG$_CAEjT L.S*!\`-v'v)džNnjqb!'PIUퟂw
TѕpCsOe.D/
+h
hzb%`
@ϡjVy#avdyU9nPC]K!0mv1&NJ3)HAfO2$M%qQvSʅKp1fag
hD{ ȜC1xPCsdG,=Bg"!;.eɹE*9%MwF_Q]u-a>CXb!w!V+gRaxS %QRG>/0',9wK8/3vq~	Z/>
+8k?גFaA8)5xK--zChUv\OIU`?|T)&P̒JM.ULJ./.],uWN376UYtxy{K*Q`6ŦA]l	wƬ^PK
yp65R"org/hamcrest/BaseDescription.classWkwG~Vky[חӸʱ	imJ@*$NSZRUR--p+V(RN9>po<3^kmEi{}DVZч>ₘI(VJ	k4TI<+4<*J_bO'E|IxFųIlWV|ϋ/
ׄ[ᚊ)h-%oLASf  >^MlxL3eRYΙNI|ĸW,
vLTpѼw,t,7R> i[uS08o^6˦]]84{R.QL_s93Q}Vyge\oP[N̜^c3{ΉK:z?'zC{-5o:WqX`ѩ`[.ژ~d`^!<:uFcEo܇T\C9Ypz
G	z{Woi(nh6Ƨʾ5OT"O|;SPCA=bm#ŒZCg-8<ʙХhXnKZC(ZFecs=xf\t0'lϼ^*E,jg'+U'o-6ֱ6tŐ3}j}=cs>^d_~(α+c?",浽] ub,"q\1Yc:~e:D\<`w$%0l<|q̅՜~>Wa~`_}%+V咎Bot/^S :FpPğ>1bp@{=<";;nTPoܚܸD)ӉeʋR^南MWܮZI<p\.i̺_[u]6lO`MB7&D̥ 3;{g[Uӧo-H0·Fsٲ^QΣ,RpDHe
w񽛅A>7q8̯a
焱\͒v@Q|3{#>Gg.#f'%B)b8 -eGe-Y-4ŰAVmQk8$ՍⰯN)[p]+ldEbKxuۍeh.eIkdh]D>*ބ.|Mo
]n&wn{ݔ=e]F#5tήtZB:1=D/:_;Џ;.Fa7]x{0]w2p13,(qeUofe(9_01F*kĴ'D]7ѽJuMr*&W\5x
RP"2(Hc;`6[UVz k@B m!H~*DP&B K"Re%
)l?_ܹʑ(J*
B()>"(|7 ޲L@;94O!&^DVP/!Sc]m5>~~0M1iFv!O£1fHHHOmk?Sƚobﳡo'hdM{] md{٘lYǰs;NjVJT!nrs\X<'<ZXzj}{
Ev(
!/.h4!~|NFP8x#h乞$	KCF0)kK^qdtlrm3r2r=Ch]psYryxeVl'YO5+Č9RPK
yp6[l5org/hamcrest/BaseMatcher.classRN1=d/T;t!aFG\. l'eP3tH+]i\~a@3{s9=;"r)İ:6,lZZb7b^K0,TnS:o,W=
e1ӑ>Cvû)q_\qt.1or^nyزsEWjTm[*޲ŃemjFKfw\څ!Jɚl+n|c=7;Re
y}K80I#vakrNK3v.C.GeHO1a5-r1=D0ЋR&;(=IH0K+`.S^	AmJjiLMIuN:{EiBn_"XdyPK
yp6iY~org/hamcrest/CoreMatchers.class][E[vmKK)^JjMj4h"hu	[Xt[yzwWxCxf	l̜ϙٳ0_5\gVs6_hl5hj0a&ؔ5fcHJ^Ue[ެ@{rtUc4-\nn(S2ʫks0m[nݒkVԼ㚋W6JZL&kzX [
E-K:;5Yr.X[U]Z)Fl[gbk#XcQm 4ZhQD(w=MXfw<H|T5EzΞfϰKCʑQ.sJǼADReLf<
.mtӊL+QucZi|hz5siRq
hhJ%П|&Bm7๴KtrOokycS`䜵HW;5K~o4oU]-S]kNcBe/ktB[zr[2[iDM2IG?ٌH{>lFxc7x&t?9~I^g#>H:Ot,aY` S*pNChyr\TK\pT3\r
XʳjVU!T4(LeyU(]%*=v:m$v`^[˸Bm7_Zٺ!ڞSL*Qzh
j|ǎ(2?MbT&1Vǎ	C^acR^La&2	2v4fI蒱310&dl:iHܞwc)[B[xW{umRK%Id슄4a߯cgIRiSR.cR%X}En٦nU;䯠q3L
T'{,!g#\m?$HNy<9~T~Lؼ*9+SȢJY
BBze!?v8&'qQ?õ%yqK{+PǛ%"(>^PK
yp6X)org/hamcrest/Description.class;o>CQvavFĂԼԊF=
IJDļt̼tkMt}̂ /d	YBPK
yp6n(|org/hamcrest/Factory.classOMK@}Smj/"xų')xچ!nfS_GI7"p`fx_q a!d+Di&&2WK2^J|k+kJ}Z\?B$4]I]?GUVC"j4?"w/N# \S&qa bbˠS.z5~PK
yp6	l!org/hamcrest/SelfDescribing.class;o>CNvvvF̤Ԑ|FY
t}\AIf~fPqp~iQr[fN*#ppjNDERf^^VbY"#4J@sRK@b`LlPK
yp6aWn$org/hamcrest/StringDescription.classSN@=C'N ,!4-]PB.,] T)-RAT<:@

%H{?'Z3w'%L`bZFa
fqʘSa=9^H¢n,	K	|m1$Jʱ)^~\%M,l3F3JennD*mľ[Uΐ*^&[MU^WMhg2%5(^m)q4K:pl3vc)(KzG8R!ȿX˳)͟.:*}Exa*_DOoJ0]\ZQ1(d`6x7EN,cV8qB+niL
VI醕:15*n8Vh]y..m+}+{ ôҋUG6U1p&1'.V4N>LS
{~#K".#f/vjwJ.*ӟbГXN.1`Lp)S7Pz^I@J4[Hi^Z#b4){_A'<8?T&OdC^<*PDjU|D;>@.|ػtL6uGt4r͐,sҡJ\"iA݂$1a	}O?MYn(nϐL*z-VBޣS1d=PK
yp6Э,oorg/hamcrest/core/AllOf.classVrT]DZ-[ii.%))ԗ.pM m(uҘȶYf'	/}:s֑Ūv`<}.{M|S1G9\F5>eƧdp%9⚊5|RsץB
̞vM'0Y`|kT:SU억cn1.E]gkV}RQ]O ]l]G!Wm?Qls4ݖ6KIw"0p똕Ng>1vGj_(/Q$6̖[-
4];'A	]y'2#^DN@mc5ʫݾkum/\@T@ʐiESr:ƀoXnGS``޳kVbWl2H֌Kq@Nˌ?:텱,Em=9;uwZ%'Dơ,h8W+XװM75|[`FدyȂa庠+
۸k
wpW"e+LDc.0f4k05`=M)'tm߹wNl6GNs77̡oգ:oeTI\'r81i8}+
FUq	~_ Yv׸K`)YyҤLP? ߑ19N	&i,wS6Nu[Bwd|+'$)ߐ8Ę!?`S7.$#RcÀ=sw
Hc1oR[-eC}^Ay~C\
zPS'S$~^$*o]#K?=߾}XeʹIE.QfPQJcaO<sq&y&Lbp=PK
yp6org/hamcrest/core/AnyOf.classV]sT=ױ-[ii>JRR6-ҦƤEvDDH2C~?W^x3?+9UKe`r\-R
[2~۾onYN/۶2EoOF8BMNKL?nssYLƉ0<?u=sՒPa4F[ËiXdž;>]
&
9W.+
>Ӱ{
>p4,
ބaS3i+
X$>޺Df`3y$>v3iݶ;&#\:)q&KYs\~G~JJ\w9$6<@̸!/'#5u5]I<0T+=ɬ6(35_ayV>/|J;/N94ɚο5ʢ-Ji_S\)M)=y3hV PK
yp6@;
#org/hamcrest/core/DescribedAs.classV[WU&	LHpK)-K`(%)Z'dh2LzW_|Er?Ɵ33&˙ٗoϯ!bQR@2a|n%Up|ap!\v/x"Ox=|&B[`bUKյT˲DV9Ub*kV VdK)1C@nS%̴R9teբ&[5|x*riܑ5fXL:&`QYj9e"M˖;S5JHǎ1) UckJ99_+ryS6T.GC(RvI0oj~Z=pdӃJ-j^A⾘}~^
.iƎ^<'(ŌV`0C}ld&vYlZa5ە_ofj̳8q26jVئjēyM-<6xKbS2
)ew1އioGo&k5CaK*ghO'3	o⺄!Kk4ICpc"
&0)#E	%XDYB]BO$0EXjؑ9v%{ǑI{IW\dICJ+xNv8}>iA8N
apy@su7AB"Z}$?%!\n8g/py=3sqǺ^򰔓Ԑ0%$f	"eLH72i&Sby1&LTnU7ws0K7<-u
{Ri;FҰ[Ze|ǻ;Rd=WAJ[s6|nw0tAyܰPK
yp6.9=org/hamcrest/core/Is.classkS@
4P"w-EҊ-0JGg
K	SLRFtFG?lK%gsnw7/Р~*ƃN+7Hհ2ЅS=~3en2=axѷm)ɡڶp
,0B-ϴ->q0\h̠H)&Zis)gOUc|U0Kj]zqEujp	#jgVDtMݚe\a7<9%Puh8QGaFngG#{!֖k^6T˹u6z`Clr{Z;/h4m
]!
5%
adh3Z֑.>{׿^
L6n8+UIC,mbi#}Denwhhn>ݔuPK
yp6fy$org/hamcrest/core/IsInstanceOf.class}S[OA,- `[/JŻDIH*$B6vٝO>H5g;7E,9a!  nq[Pd]AUU}+kޖeF {JXT+Odvb~G
ZQ;X%XwyuR-gLU$qIP]?p\G}c>bոr+':sUK^*QNIn bgMw3\3gZK3'lŐ9aů
yOZLpMS&ve(i/HM0kux.Ҏh!Vʽg込UjJgkqM~H	"BtyG2B~!rHV&	LRaMlf5'HOlzMR=3ݞٯltS|nP"e46[PXE!0`m\d|v,eʊW$5/4ifTs^v'92&1knz㆑7PK
yp6Corg/hamcrest/core/IsNot.classTkOP~
vUq7QTƦ9Ʉ-Lmel:"??h4in&}yos
`	[H
Bx#PsȆ0-,&Ojcn4mRł+mq0.L|,??x
%مB4Fa6Jw	ܳPK
yp6Фorg/hamcrest/core/IsNull.classTN@=[.~)kJAHH)}8V0rvE}}R_+:8NCmig={̙*6cK,㑌ŒWbDCi6C:+1HN`(qب
Wet
[dM0ȉEd>,PR?YZS70,\18jz/ 	%LNH2Dg-G".E"<63<%C_<gHއ6PK
yp6,dporg/hamcrest/core/IsSame.classuS]OP~VVڕ(CD2QD%*&ѻdlvFxƠ?e|O[F;~>~`thAEiyQϝiUCm
+`?x˝Nu{ 5Ã'I\v0_:Xo2(6eێx5资gVWH&liN%8}ugy=AiQ:U^)+@~OqàoyvK.J)M:a|qfd2SW{pǢH_
{ݮϦbN_z3p'ož:pِ.5VzGϖN}1B7܁g][^&aC1Py)ࡁ-l3uIxWX|i#}7v:[L_.;#K±F?F?$}r$
2B:F9HfH`dyz$AB54\XɺZT}>[f̗H[׌ywd>AU>C~r(OV<,9(90s2,rЎ1$12˅I([N0EJ3jXU"_17w#GpqHu!^ŸyoP
)oPK
yp6s^zorg/hamcrest/core/package.html=A Ｂ0TAH1"O͌Q2
@g30RQNV
`rpbT-eߣ~ѓ7PK
yp6;o)org/hamcrest/internal/ArrayIterator.class[OAӖn,V[.D"Toܴ!4i%'2ltJ/>h"H"~(mbCgv9;gs~	`	܋
WD917хI2=Lx#ݘ40cు']\J!Y#r)$ՌoQnN@ڗҜ:7"(G0ϡR4)D͐g{=i礍0x`!:Gq7PK
yp6@G/org/hamcrest/internal/SelfDescribingValue.classRMO@}$5q@j
@[ $kҏSb絳Ef9?	G!f4Rq؝ݙ=#Y(}yl&LlP8P0,N9wzoTWb[rKW
ddXN?0俅]BϷg\@##g>>z+z	?#1b)8m?TΔrX2]A4u=U:輭n
nȰQ2U.u'`
tӮ,I6e0O}g4'6lZuڗYJE ͐|%Ja9h4;6EnmYr~ߢ6\g뉡oZnMa{*]XN-z-J	ˋ$tj!Q1^SNجђJR9OܱH:6wzαM8C<9tG^WZR3ؕtylqY\e0-2ySu	)ޅ/!??9GV+q6h`$9
%zC
rHGet*d	Xu/J`Kd)C+K<EZMvc<ބ^֧ܴy'}eC,$>M릃L.OvJ¤!/$_M)?ϡWfЅ0EvU2i%h<-_rBnTgp.nF`oPK
yp6"eLorg/hamcrest/package.html5A0}~Q%np@	.HГeY.sJ!O3x=SL]$'OєX5KdCPF\3h[y'~Jk8,%!1AINo$؛Ԇ:M0!GvK}P^UL6DycWd2H6eΩ'6GB'`v4 .ث+PK
h<('d
"org/junit/Assert.classX	xT>f^^5 0h]BAbH%Nf,l EK.V[!֥ZPVm]VjV{}w޼y5ߗrs;/0X
,R5*I<exFgP>IsNQ9**Iŷ6ߡ2|Oq"ߧPC^R`D~xYWG2/̫
~JyQ:WTYoz}T}H
x/x]灿zodS//
p	wx߂ORpWP I{h"עUcc)bAª.3FԳ{IpHLǗe){8зH`4U?'0"ekG,F6'-Y=l*nEެe4FN
Ǖś#QJf^U면ckI]PM ۴mjE[hڊvvuꢝ\T4mEv-ErQѴmjE۸hN
uBlGø	c[Z[8OZ2-ho#Z$xL<VGSQQЃоXbx{	h-Z}Xu
b-A(}]ss>HN p.B$%`Yvt	L6d.8F`KGʭ`b2C3!5	Ğ-
`(-Ms|QimmƖ(PimZ82o ؛En2n*`ٖϪ]T&&vˈ2'WQ[
[^cvU(T೰j*n6(le;ƪ̵n.ۅ\NٲkUtX4lw	]a8Gփ0
z%uFDDqu9_Y#\e9|v#|7m"{`*Bb&yൄ${0
D%
2e־lrdKaKj+PnKj-N#2s&Zu݄زǰeaM<[SزB
ä5,nd+P0";^^ÆLS5Sb^S7S'ߏ9a}qsLˣhA8x1e'=nlĴ	bb-X.g!)!n5$S|w}X8mlۥC0(LeP+&K985wp7l3!-LwLi[w~)%/>ʻo%iAm8-mG 7C0۪}\L!^ah%)⵭mVRT*-r/.0wÁ,XƃKw/C^թf!g`uОU5Yͳeuqս\xyhI"Pذ4[*\+pw{$ZuAb测jꛯ:48F$myf4>qxp!`;p}w6H߇RCsچ#kh37BhL!i؊
߄i7.
EU,~ӑBf;g
Jg%@E
JXH~t-8jJ'՚梚QøH$^n-\VhnMݤa0zؽ±Atk.?50tgSTǟAAh^&Ef/~%0-H|V:ߊ`2|kzzQ֤xʎ9hcBQ!hyųy-^v#ƵO'1~
s0gb_&/Ѽ1ge1Uħӵ,0
C+ג	Xk}KEKDi]iDAq8pDf8P^XPRjwί _WkT#{%+ٱcا;}'xPK
h<Borg/junit/Assume.class}TkS@=KKCC<|
@RT:̈a)I&MP~'wmR;gϞss.ި@J)Th崊?=}cg(xsb9Rd"D*+R5ʞνBp%u<[B}RBI[0L4V*|ÁҔ[ltܳ组Ig/jXH?CI3Ɓg:6@cE$TI8"TMwƊ)WbJ@5t"੆E,)X
WpUU<k
^jb]AN^1Maڞܪve:S✫^c|?Q|}=8ɽr-(zj{"{ANtqZ]ZD;'hYTuI\EgfuCCaKh_i#5ujYB!TI7^*]}"k}C.Z42M}IQ[Ћ>y"%LO
uF`K4Pp	4~ jTUg
"(L:yj`0.KQL%%6>|EOD&'!II#!*Iq
#Tqu:ƙnI$!隙62`=|hц$&id-wPK
h`>?aOaGaWaH?:&.5T|Z!짵vvn/Dp|h3)G
:'t:G͗bP}v;NTGQdf7Qod7+0T.koON+dZr	GGBGz
Mu3>`lA_@-lPK
h?aWa[aGa@?X&FKN=ׄvTfj9t0UFYHQ]	ݹ$>xkTtގca%eA'|ly&E䊰<*jgBT^LgpԚl>$:+h՟EO %c}l47PK
he2؁yq7ܭئqs),eFQA{_"K`
.e,j4u+ӊE'
VvhDg5#W
2pRJ>\y	Pp0ҠFbQ(kPRdYzL|,wNu3]g.Pe,z}ҎHC-;.;骂JQi\v_a&¤Ys%(⤊8 zTb2~*
XR129c
^|d:-rMX*"8GQ^Ndb1ȀT}xҏfhUu^j1Z{TLkĜo)h--x]Yh)yBiˡΗZЬ1تۤҳ+ҠbZ=wӻEIra7jvߩwiyHgDG=tvD7X 	/)hv`Q'CxG{%sOG92}K} }>ֲ.@MQVn 8ɾv톟%ejUj5x ݠf
XpFAmIr9VyۢN?^0(.~DcfٍO*_C	(I\J	
u/[JdΟ9Nwoֆ`Ѣ9߄7"T쟠F?PK
h<>V!org/junit/ComparisonFailure.classS[OAݶtYbՊr٢>h4&)ZL.Yv4hG,%tܾXi~;v()s˽JfHa7o^Rj1h_0LO4Gm!
ET'uQ8rˎu%zk8
])TG"xcbM;":KLSy$]i
G3}}U%30,rc0b*xh3,\av:=
jRǒ!uͽXtE:mW\.3|*^7QzD=y-b$=}4Hn|3s}ktg̥|r1OT俋q@G|5dȗJZ$)IIvgP&5LM^p8-\5sLm1l`~L;b/h+7PK
hZքɦHl)Cٶ(]@uIܩU6f=T\x󿮷SE[<q."PK
h<^org/junit/Test$None.classmPN@MX6΃(!A	B
`_)Iw6|G!
W=?>a/D[>}NZ%LZ~
LlaоVZ7qFIzrZ>ϤM,ge9
g+zR9̢ҎsduW%ǩta"sy9]!@c0gB/tiݿ^/><kT'0nrHw[m^]63[ECPK
hQѬD	-,;33̼8@†M[u_Rx2)HKZ2b#jCFY`X)_KeiN\m;=#ԵVRG)U;,8O,=*q.k
j_G }GA\5Sؾ6#ene/u7`7I2Ld﹭a\\VƧ82hfxQ5Aόj7NfR`~ݸnrcG-,$/x~|c<ɉ8$)b-1e˜f`LU1a-"[K/V5cAX$M 	PK
h<&1org/junit/experimental/ParallelComputer$1$1.classSn1=NB6
Q(HH"lđ㍼ު>BU@Js:F!WH?q\݋)IQs3iEh	-
C2ұ&Cq$Đ`5ؓX0abi}Rp99QPi\5aCRO;&>Zh(ᚏ>*xC=`Oa뿅04/,8I6نU hlӥV])J24*zViuV9BYGtFOcM&:a)Vn}ArtJQJ5{Ep|BsF#T[TzkX O4| 5|s
5V:0Xcl?0˃P
!l\+R*Xpenl	+Oūy϶pha'c;雵];cHuTk{fb9nkŝu.m5'SAۦŁA_t]!}A35O̭Mަ1W#	!*ojfGŭUTfYm;zTEpj~\2K	nƎ+4%H"%ͩ9Xge~cH׽PZbVÇtQж̻ZAkjXұ:N~؛R$ƈ_`U[xvěSVu
k:`]Æ/.o=éc֬+[R/8%2w:Mى|bt)gڒFpRzaXS
U~km)xs(WUA\
1kƥٳ"$]j>}ST+x|Or?PK
h<=	-org/junit/experimental/ParallelComputer.classU[S@MD
Wp((VTEeBY!Lt?3bqxv
;9?|0{r
檊kULhPqYCY)vnm9۬Vy-C9+4LYe2H.-eΛ6ti/%YĒ*8jz'4]UeϴOL״mnRaPRҶd#M7tT-9H6.ӂ&ءP]@9klzK~OO͗f6˫e]ޜoy;PM(v-{7xՃ\7cj삎BSٮ&)#KZuW<)WU;P[1Ӡszl<^$EzZIV1ð_={9[w,Y֘`хCDBSv3hVNH2NvM`gY踃:Nᴎ1QJ,-Y&=8myu}w>\UYӫtk|ŷ^5fRX[F"G(FJiH0qfDD4f
GE}DZN/ G}19JcӒж,*l@$'>VZ%5b;tقXCbN89Gade(z8AI5:O"Gjzm3:CaI)0CyImvԋ3$ى8)}H^
al)J»z@
{C:5$jD.wI&pCzw]FPK
h<32Aorg/junit/experimental/categories/Categories$CategoryFilter.classVkWg~6U *+H^i1Hୗ%Y`/J{N
Iww\=ygwޙ?80v`V'pǩ0j0i6aÛlxIF#	c3:L#ņ4fؐ,d6zذ(
h\Zfe6_Z\ĻlxO`IǸJt} ^OD@Kb!3|aC01__	x#[{G)?G?gme^ϋ;sDYժYI-/YU̽#s׫ʇL!QMHfr蒣+<1KEB)R27&-6HVHU{S\]G־CY50	Zt"Nn!H< |[`56g	G
I&S:hv%"WEs2Qg BƁ4NSSXVy^`C`iUe;DxDs\yhK#se(L.jN.r`nG
07npꮑ4s'ֵ:7rXp[ib9DlJnd"`i.Qgl1N~LPX^]/4=8H\auc&nh#}>xMn0uiM[(@z\}hGڇ6Zc#gl<]pY✣2kзSvP2&=a"F RA'缕#5DRUsD5z)]Y(AKۦ1{G('/Н.EJƋz^F]/C$Uޛr(^"?A7BoO3{ɶ8[*!3||8vzMHG׉)ieǨ,;:);DiDW0U(OK5e-ϭ/3=4tikg3լ!Oo;	Aw
%vi,j/iJ)^ɹу823}+bAtz50s~LJKg,PFeJX]f!qgLqRŀu4ZPK
h<! Borg/junit/experimental/categories/Categories$IncludeCategory.classJ@ƿ1jU)*"HQToI6žExv3߰oNcG[>R$P4ʦgTQ
}Zʜy{xPK,@
w9ɮ P -04CQf[JG|@@9MG}7/ʸw
]9l?c˚iZwK.&?/nFB.CIFsk/sj
QGhj/+>SЇqWJtПzm"\ar$គ	L*'rZd\ݡ4J=Ţ'\yFmWmhTo+R!LE9VCoQk.k蕯UV@ͱx"Cb_^	=_檨	__.h`+YߎaE.;)"Dhʴ*Shk-5ͺ(bl PK
h</:org/junit/experimental/max/CouldNotReadCoreException.classQ=OA}pAXx116SͅB~
,9vޞL,(a-fvμ2>VUFHDܗ6QF?\P
NЮ/TIF즳P̐+rD%q0M=9ID"MI1
W;6f7k	rMW
pƏo(yoE%WF5F:8{G/缧*OsZ.6PfUgPK
h=y:H%n̹dXoٙYLLD|*R	UW+RZİoޏ߹חIC?Xͦm
|tsM):v|bR;_xFXOb(==œIkhhb\6%%$URvPPW	fn1?"$|MckehL[̰oC(}Đ`F:f#
BB;{+*\MZky-Z=a- GmGkX'ma|wv=l~n\5,bPK
h<FF*org/junit/experimental/max/MaxCore$1.classS[OAJkEEV
1_L0HHxs(cY$*L$$Q3z	`\9s_h̻n`<0zF&>O*&SJ}eV&Q,SaȴkӍv3%m$=,O?VA[$13<cpZomPޖ0|+!O6n?.@0+.vT0~E!Ot]%`0&4QIBjl
uf:t%6:N
,XBb
!.(0L*yLFΞfKeQSĞ6WƉ<&H2Z{`hZul,_^:&l\յa$>UsV;Fw-K\܆{Hn!pڹL'\7#ԏ艗h#"`Яp
n`;;A~ξb	#;O0ǘ8N:ҊM^:+SZ7|L7q<%xWiU&O?PK
hMY;
߭=ޫ}*x͇C,p+o,~~@yS]Vaps:܋
>O( 8iY1
T0;>bRтY*xLE7Y~OE;y2PSK*'|EW5uCRmLJ|W`qm}=[ϻwuvmX{~Hmu:'zWVW23,5-f͠#iבn3afFwր;n0dTo-:$-Vh4/;x7iw%3X羨c}*wX2޺@.2*nIHv1:d&\D2ݚmgX-u)ݢ
KK
$fT'3VA@sK};+aub|O.`hx5~a+S#
?O4tq.İg~'5~xiP~4O}F#Z KJ5ՐDB0Of3k
~?jgo%.5~
ųt͒pj[Y#TM݈
6{M{$"~$QlU)
YFtϖ$`nKM'7tE1-3l?]q~;ze9G
0=N6uNEє?74y͗6l2Nid	-:Z=2~NSȮ ?ۺ66zVpISQRegDX7|Cm(D&rp>O9bK?KzbbKa,W*=#%u\{J*y>Sa;9(ݢAeM6PƁ]Se/rP‡NUX.Zs4rD߳Y$Ď8&P=&wҳV%9OZ}L?7k]j
LZkU(Pv\$שslQ͵	(SROIl;Kb%=O=%jj2ʸpm*PTp)i̗BRT7,{$vCbV1NyU¡Ϣ>p5Yɢ1YڶfAg}F`Nصs,l}'BMXus{\&0?GS "&@t4g;n1Jrd:3	y2I'5N$
X@6B޶8QI䵾p7EGqJ.:ғ`6:~r|1gb
X$р%HÖ7x7Ht	Ldykq7]\)PQ0ӎBl	:1t}ڨPK
h7["IETKsfidRMo۪3GdNБ9E{r_4^J$JɛI$ơvmLPZa/#2">yS$	-(kFMQ)!s7~d41>G	><9F(9ɑc>lL}
q[p
8I	՛`Ҫ	D5KGj
>dхrFiY,GؒdPK
hGe:org/junit/experimental/max/MaxHistory$TestComparator.classTISAz2dH
$Q\APUCldhK͛ZhyY史|=
0ί߾cR|
8`g9qArI2a#20ļW[EnyUemR_7\vVɐAFTosQ.gh.+ܙMi)%ݜCeTŰgި]Y	Ψ.'C1ȥ@"A8
-9Ƣgdn'NSRޘnpnU֊U&ܮKm_%opMr(6e\eLeu[3g{A^9Lʌ;%>fk^<%TEf$隌Q\Wq2T	t)[(2tƩ3ORжST:K˞`Sؿ6
$pfm־L#!
>B8d>$E%=ssh~r	=`ɤ(!+ m+I$I+gH/|$IB1ajpVЎ@!('H5DߢAZB*DW3/hdiYCl-hT&jф'S3{^d?ԁI"DLz{m!{d'_Pco	_"W7kWm
8y=WސYD&J54*p	GeCBDL\*b#db.@8<-)"t=iGPK
h<+org/junit/experimental/max/MaxHistory.classViW֢i$1$$0<(ւ%,+aĀPp$LZ=9;w;xxK>D__za4 N8z}V7#+*:rȈcAho	4yiexQ5d :4Њ덜Siix@0I3is<߄4Ѕ_IEi^8^nuohsq7|_N)?psguBTnVy3?j>|u.jF44XN0me?M17' }ɱmhMNih+{JknrSDqlde4bsC%cVnDs]dC譅Jx\of$֞QכO];vRK7ʦr[R7fe;j,/ZMYYF4E(Ѡalf
&`gjA9[0<ڢ449
w3&C#voLrfP	5Fvm&pZCKtӌ4lUEVٻ*2pu}9%Л(SO{v!ʽC«xڸs8G$ZdlL]
RLRW#QLi-aKX=9n`;5wVn
*N,Y۷h
+VՐLlr5KaLy/’VO11q6eb?Ugm-p`S1+q23{;6R4?gy`8c&y'5t_J\ M?/&q{-"&>&>ؔL*7~BTUKqrpj~e?Y8n`x5eI8O/)D)JCFeU'[	,{ڐCw*bY/	S=t֜bkفZhKN.ϕ-\ĕQF3o578U1]$Ey=QHIɹsM4]_Uf͹ŏP\;.gWzHT &>뙿MOsQK+7y5 7FD=.@I.c
|m$iNDs8lA3hi_3ໜK<r&#YA+h9751~2mouN@G-z׉w-QXq!Fᰟ
qlgx-dM?У2p?1q^qV=ORSaFIYna1aY0aqDqb
Zgqh+lO;>t<!ldKUQ
y)|k
vάc&/XF2_{»(]D`I]*Q펨ZV|	LFi?/X>{Y֪S^5iO6HzB7-RM˲^L
L7/k_y⧬6Z	:0W!$%021lAdzUG8v08"ňUO4j87kqN$ǀ[?!d;{w}@0IT+bS\_djIw:#Y~F@iD9&8&NYfG)t)yr1N)BO%ym"ڞ[

BZ᪹oPK
h<{|4org/junit/experimental/results/PrintableResult.classUSU.IdY#bVLDhk,P4ge.{)M(Q3r22/dY}b`ħmc(cbb]^lė7@M`ԗA5oۡ퇮+}{-2L-+ڶciWZN}ՎtӲW$od7d=5Φ.0Uֆ+eZ!fA<apBl]5]G>ARaf"p6jղk*Х
^?p橣ZtV>=Y`yHU>Cr\+q'Μҥܱ#.8Y2ګkJɾ>TڗΎت<Ξ}[
nVR4\
q-YUpzC
,^,cA/^I|ͻ"/X"l,l[Yh&M]Try1?᭠bS;?"3Ic}=p\]g=[_i2zBJ5x&,!0֔ڽwS&5t5zѫ-0M(YHKOo(1.F@6Ve\FI:$ci.tjHT/fd$0Lxv"G1{|.+Џfd櫒&a"2B11?K1{lf͌
$N%9_!H<""pL\f9\y	|c6Z&|m:/LqS/[B7_c'nnfBv+81-s7l'ޏPPK
hg( 9s3o?iݘЃT?R!̉y^BXb'nw' fLѬ2t,i0bMz4?Wʫ$-;oOp*9kmsoVY٫[5niUn8Xܮ뎭tm)Ve̓kREK+0s	Z$GYwjfiggD0zakΩ\?dXϹFat
90׮.`lkOW]5/69s{tI9lNݢk1HdndMָKRޭ̺U䛚Q9lEݴ5͝Y
bI2VdOFO9dV(uՎxU1Q|]U)<[FAlcO@%j/2(mC2̶gB̈%=e+DMw7JdbLω@_r̦a v |h:1RuoOn͂gQG=Xo(ZA?Z-G?@J}K|SQv1*høGxK=P}@R`
#!Z7
ɇW'hUBI?Dxx]ꚢFHQ–p-vmٹs̟?XFyBCFE9ySb$!7XV@
ϭwM0^\ЫY!fڦ_d_e`xj5KH8.wM~m-yN+rp͖}nw})\oa)p
{S_~$w/ZER.<5kba˄eC_emt0#Uas?p)Jb{"`xR}n\u[LDFdTa9Ug[M`UC)e)o7.8 Kg'yWDR_h5DRta/j15;D+b1A:~Q*&1%0F;} eb\Er5Y3\\K|?"1t&;5PDG>Nqʄ|4qwFГZ$PK
h<-3org/junit/experimental/results/ResultMatchers.classTn@}['qcB[@BAIhkBrT)"(R%.u6rlUNE |bЦ {o3c;j,X㑉TLT-dĮS=ed0ʕCW/·j'px3
b;AØlHP؋&/yDNba\I$|'PByX_BI>&Ro	ɶ؏,F16ËY+QpՕzrg?rkw#9TЭDbhTu(4uJtJнByn8z.Ѿ\5
[4sN4maJ	칅iӹi{s1V&[C #}i}awRz<,ӻ3%Zs
i-nckΌ/X8_r\(ԕ1A4
qӉwcdSPM
^?Bȿ?MBBBt?HLDRFREWjPK
h-org/junit/experimental/runners/Enclosed.classRN@=j"ظư
]a0)eJr?2ނ6{Ν8f^^b<Lh`2ȞT22TK~m+>pWjvːm*%owp>Rj0![Jݦgg浸ZFݙ
:g(}k n{BˮPw?]aH_Er1FsasH?u>7+W)\-t_c'a]PK
h
G5H4e':l;8	֥\j9ϒFk+^2ahLv00Ds*ØRaĬGJNL¸͜ESca(F%,EhN<ti1yF=ۂ|^yIYҙyCYq=鑜^,V|؜mC=TiBI/|Q
JzrKl;v$*vXƩ)'L!^Z(egb#,ycIÚO(2znbsҚ+{R0}8tzv!oy2|IϥK3F2bnmX.cu#!}%k!S*XU[2uݫPCƦj*V-ȫc<1ɼhPLD݉h1&5\74ijj!{(Hxsu,GE1IΫAV[ICC#=?IY
ۼ!,f\9
_jJ(XSr,^+}ly=Jժ:yQԧg	؁Z"ʨU[|
EqT:Ҭ+a?R/vu1N]ZW`s5+j`
Bs	*^Jk~4MkK̿4993c
ͼJ[){EHKPkrGmPGzHm5%m[a_嫰Ve&op!,.c+ZOP'|{aCW'}h^BYrRe`l\K66P-$iUډ-]Bn.m59ZC(1({a5y-ޟHM'D~pdH[n#	D	Iކa):)F*Hk܃5pۜZלGJcjv5cT+;{8ڋ1I3Njg{Ł{)c!t9FB4vvV	UٙlCNĝv"bIk[?]tt:|	bYp9
g
OQSIH;tfȌ`i"
^D[9rE\gBHMc*hDʅA@7lh=7%/""~CDždz	
Е;
.TB %F	'A&Z7S-|cP>EvDl8|#CL;Qzq06-fg|3;`68jı@8љvS`F:ޫذҏD-u!p6+ IOzMSF%VS!Ukrd~1{x&Ĝ`N3弥0ZG%FFpnd:;V2WE2=,f\E\}:F^5QY*o%.8C?<56H-nBT&۰ClB+堪=d[y/PK
hxfB,9u~@
2plqFfwel9^X0C~]}Mg(z6>MHO'җ)Vy>Ru#\Cp<=x^'”Ȑ+Aa(H򸡂;{W@PViH=CT39nZ:{pGZ*?P%Vg	:svAW&9*ÁTH,sA8KUhoX-hj0<\nou5zJGEԃi6g`Rqlf;YYdFɲ|;E0T9Mz6=D>oП:MeЬ贇UO;HT!@}(Dt7иt3t+9NOQ$i]I47Vb*IC8eea5"'3$Gl*$`>ll#PK
h<컳yDTXorg/junit/experimental/theories/PotentialAssignment$CouldNotGenerateValueException.classQ=KA}\r$&? XX*DB7ɐl=߲,(qba!ov0oUFk>6|l
,JF=2u) nIz2J3;I`4uiGf9"=7VV`'4I4wCb(3hxJKs!ݶG$a3xJ(pc2"qa鴼ɩ@$U:Z|P)GI=
'.r|YY>D3A笥XHUʢXqLerX
JPK
h<
;9org/junit/experimental/theories/PotentialAssignment.classS]kA=lZ֯bbROPŖ4^63evg铠GwK dvf=s3~	`#4p7Fq?)=ސ&+dVЫӄ2Z` yN@
Ի@00$2TgM"ʟ`s<Ɠb:=&bwD*qDETt_Rp"OdI*Eލ'~oFr3v0%W)\.BD3kوe<2Yh6ʛ~槾h	mD3omo	,P/;eQ/iW ƃ]uoF	2VxmcW*]FxlOe,%3:Zʈk
ƭWҚ[#\y伃592sjPK
h`Gv8OLĵ|8?"	w.\=CWU9۸PK
h/*qB!j\
˷!sNLLt$W)8&Zy9bA/Ó}2M[S^ Vք-b}z]"v=)55b@0V4L`j!b)$V5<7
iXc
;kx

0DaHF4ȸ4Tr`W@q$*\Fȏ_ɇ=/QxKtA.C_I,.2{de,8GҒ1iFFILR]D|ot?G=J-54zu|q:RG&MŐ?'
WP'?d0E;FOXEb۠ؔ0na(f100.aRS	SjD4+kp3L,;lMU.7]P,l;n6p=c3q7km1.y䶣-n(ƻJB͝鸪MmuOU(o7Ő՝Ȑ:iaaԲMKBGP;7:."qf>1ůx]
Ll!)&TcMu^bE 0ȈHw]2	35WE¨xh~_..v&l|&5!r̐%Uؾjm/"u}VRMͰc.9fe4E:Q/2Z#^JHx9XN3aוتKzP/R~'B4_uͮ	4>F+|u_xQ!qôa`c7unEv&_bD7be(Ҹ=kJjW7iDbQ+yG3D+' ~`@At@Уԃ֤UZqhVmT
ۂP}ɴQ|}e܎t}(4V7zJxں㧄z
3H):hP~` ڒϨҗ/~"zr"J1z=+̏!ч:OϿbOPPK
h<;'x;org/junit/experimental/theories/Theories$TheoryAnchor.classW{f!GVGKα:m:6]Y.#%M3dcejHrcl{f*-,Nv`0$˲*Cxa1<ɗD|焟'"4|/9~y_%|YD'EnW|U<ǹ&܈o؉|Sķ|ʧӊe)fL>Y#=bSɳy]f^JNEK2k\<ڱ,OD,1aYyFNmUKMt-.ySa8T@@]֒٪T
M}si98HDxfk$Ca:dX3h~b3iY;)*J>Kbt0uwdPSVtܴ9Xɔ
~N{lK;cg9BS,bSя%jg).n"þ؊l"(	dtN#A͖7۝+3l:QeOCj@qAT}~ ͞5%\",[4i-l/Uŷ=-M֧ϜU53nSxAY5i*Eܲe=@ 
EV3Rٳaj{aVM%gY}7MޑXT4fylc>x.t1QbXᦅJvsqo+tCs/3T>W=ŅK&1%nI؅$4	MS>*	{q>얰~$Ǹ"0*'aeT2{6U}P^2
ʌbF'#ҊYَZT-֤dȈ~[bG%y$,^¢KpT	7ܔ
~.~?רM똙~rj(9k	<쿕;)>-s{	\meSLWgpHqfY[
o).oX*-Tҩ;)sOaYNieDT&5j=6C N&A+v}]o!xSmZ3ThȚvB#c+8j\Nɀޠ:@?ۆ{D 'VMHkK.M@vRV5H*Bg∰sTm-,X]~BF;!ZOWI&ΣG]\obݹ^S(QD}UWʪGf	`k_[5c%bTI+a-r:JbYVw2}EXUTBWA}5؎hD(څ8Pr''/@gVnu?
l/!0"&<!G83QRx?Z08C'u8A29CdP	yߚ/劯9L9%8T!*ά*?ND!r
R",b5umH(kX_<AVxH@m~'og	`C
s%
=7URS2QeC2e|e[.oz6g6xKWɂNRlE0qR8J	lH/ExoQ)'ܪUӱΉ8O@)^[Jf,st:pW'`E*CǂW3)*i;&=tU\RQעh
9(<㴧ሗWL:nTWՀA-bx2xa:MܸEH!g'B}
!NegdBiϏN?]@t$^GSer-pP_:ܠbMTR%;=hdYjFW>#	GhTUzh+pmU
JY*N2Ej
VYC.UEơ[aj^!Xo}
4n6pvPK
h>x?gj	_UWW_qp‹xQ/N㴌'xOz1ᅂ39ƛZ&x1qaO`!-#)cڋfیI	E^8C6ESI+"z4~Uه+U.VW\2^S:ޠc囌7\;2Uާ0RΣTٖfHjzTXz39~'
>G
>%'LQ	.Oe|s\V;|d||;\׷8Kذ*5{\U?⚂p]ϸ.abܺ""!Y:rXۜbvKh[yuqa3N/'Fr_#em9E,jt절%2Wj\`)2v|m&QsS+fTd_Rl.P%쥪
tqPA:HgCd0@ˍT*l3MKO7_RXM'aFܜ>3h
-SI:^%Gbjb@,
ʠ YGc1(˞%7]v.
D4.-qsZt:5vݝha?<KGhp~o-8!qEG9huexZf!FT9i:&6!h`3}JJBs QۈvѼ;*NZQ f^sF<@FWa_ΰfo_?K9֚+w
;\;zvԻvzNpE;i4/'~>FOkˠq~M5j0@T8 Qv^֎1Y;.v]bU.UJ_aG8%!_=/JɍPK
h<
^'Pq,org/junit/experimental/theories/Theory.classP=KA}K>c'vA!8yN	ñs>`;'mHDIe27yf_
Ԅ,`^Tffq͕%TƁ]NQLGzkzrqu&_U	_\JUgR?9	fVp{^kڄ6:2ɔL
.
tIm/PK
hiWJ낑j2WnD熽9DmU<2K/	 7"WV0}ДR]Qs	_o@Vorg/junit/experimental/theories/internal/AllMembersSupplier$MethodParameterValue.classUkOG=cSq0
݂KlfqҦMHBʡ(DHQ>-=޵AH6H|zfץJ?̝;91F0?Hnf𕁯
|kNw
,Wk
,	ʨ7
?hY;"+=OҵV#_n
]S=^9UuK``[
-Khwlw^Q[㩃
[;de1wkeCIԳ>"r+Ց^dVԖ~dh)5KT͸u'8vdo'Kz+Ǝg[wFpܷ溲eKA+֌;)#t0M􁞷NC":J4GmFZG={ΕzRƠ78pq8膎qLaQ	J^(+^D}cq"ټk=cӕ^+j*4tveSy"`VqY״(<4mT)	‹qZ7E&vyُ=
;Iq00k`M`C@zيkg7#wjO?
ܩ0^WLTg`lsD?aTJ{DEVp.[2qYS*&q:$Uz)|='iȊx4~b4qOCy|T&b8%$}B>Ƨ0Ƨ
cm#>!|Q$8Έ_V_
kaqVCoo+-aۆi#Ɯdg1TH
=;?M/ft|IV|$S;M2t)	A]$*XcF_f[T8ú5ޘIcvnL7lOޘḦ6}I鶬^CMdR)4!dJ(5<瀓q
J. 4`ںq#q=L+c=j(O
.Eͳ(DA|uŠЋ0{v.H1u;M[mE
(xcdo~3QEFdBkKG\@*K!i_tYl1&9"5f
jiZF{R(PԮ*f.WgLWŒ[gm$8"&
g#1%8I2tknc6yIY謍CuCP&%ۄBTy2h./+WTK[[J89,Q肰52q1aY(ua#噎M;J
g3m*~nGPޤbC
bvNᜊxZ3jozhK,@sp?Ԑ7h@ݴ*pW5X
0XOS
?Uix?W
/E+ZopMo;
5TA񒊗5	f,f}J<7Cb7Ni;.i)1qO/}1k- d{D֏ȈGE7{cq숓V' Xʟbjq
BHFt;bںe2̑\븅)h\سVNT
vy~qmH輛D d^6CѦWr|uLO(&ZOVbB^mǝ̭Z~Ot-[_EV/v-:sg)98p>M^5c蔀Jآѣ\ȥΪ9()M7,ku&	(*y}b(?0@oeA9V8-\.!q'Bj(f	e_LA:PUxTT@yi~/Y9Bj=jXva-\6s)YVZXܪ?UYTNcYg|zk	oZ6P6spKRk;k
a{+ъx]I)SiǜO/QО}ךiKkާ@s5@}0)Դ\F݁25qŞBH|Hu1*܊A3$zEz\6@+	pK-Qp+M/cH&Q79wU0HfQھ+ۃk
nibA1}U\f)la9ZilmlwLAUKZ$u
>LO x+n荎6&RIZn)=ə@m}hc*T8p(w딸
*dDfd9Hr(_+F}.iQ-/g^r-x5^|I̮Zx=/9o$ЍU|-o[
Gm[_0stэn;Cܞ^)Xɼ>W0u']\,}I3vkvd!E=4Bf{q3VfIs4N̏U/`LSR>SH&>a
a5^߬
&uS.,i̜֩AJd>1f3.1,TvpKsu(-0^)*mm6m;2Lg1Җ6ohY'=9ܶ u}\ؕ`:.ZhğՖ=o1|k/-poYv	8ػ\Jpcx
z
o+KW%59Y (의8|'d<*l*:dEWDl' f>7:JtY
s`blək}QIAOhP/ѪZDf8ZdCAX!c%:V!Qk Mws)}q/zHc0AfkԳeGjkCC5$1}ohGfJT#%e@7
=Tl?U;L#$x{I:)´Lqߨq MiIOKoG?ӄ<*s8YRy{@BFTnE7]%Mgv12g雽ӓ\'l/ꠈw'{_qݫxR!JaU칇Hwgh
hki`~Q"
%av})/ŀ{.z9v܃mN
T>*/}
̃o
`7؍Cռf';oaQB['mGdn"LbM{UW&VTx+utTf3UڽK^\F+^e_}y.i"Ty;OdhgIpE֜?PK
h<DQC	Jorg/junit/experimental/theories/internal/ParameterizedAssertionError.classU]WUݗLBS@,MUhWTR>,5|P*ׄLL:3Aꛏ/>ouIWZ{ν9/xXTr(a%aܗO蒏{F5i[WO{l|lI#L>E
vU/6n;e>\Yz,q5Ҫ
Kd+ھjf)Yo|U9e̹afvO}ϝ.X]/kZM	 Z{$mc-rֲKJAkjմ[-НamҲZMN/d2%۶u5K{z]}l&Ke(*V{0Ď@W^
V,n%^NV?v^5jiYQM/X*q(?T\&/k	
|X<Ei
-ЋE~\IߘŸCS#9djnfW^i(0W~DsVӗ
)@?
cNb̙`s!ЕH㦂/U|*^*4UL"`OE䢢2ߠb5a^	KE	Z-xQcZDGk\=	aD9gXEˮiT&yᮟ9>
Nn\Idl[{~	iNpj,qqz+4b2ր_鑂ѮhnSb¿bJYsּN&N-^͂@G)w[o9bW9(=+uZⴔ h2&Cv SMsMtO>C詷JMQ8u$٣,vyzOMA	'
uzW's	L|أcW$ß+u+B0aj ôI(ɜ-ΘZ'i(tf{dÜ>> >nwf8囥oΓwgC[U[z51p
z*|%.rHXG}W!ƀBQjvF={Ѕ.ӎcVGIOS̳QyMAWCN@mLfך'׷gNQeR)1sFge$oNI9sʢޟ*\KQwƨϞ`U3a6>PK
hIgDsMhg*ḟQ[,#OXZ0R2d{eTPI(XIe!,GzXZFU
.Gr3(U5SDEbH
dJWfQa3VގM@یUǶݽӡ&pLEEjX+\*Sbvt0оr8|=5
Cnq;;bc=swy	b.=k61MYAjUhѭAE6"k޺F,Ni>""-np45(NٲU,KXБ
hөJɨu]6hY2xƘzJ;oi:ƐyFۈnf*w=H,,ػ;xh{`fl'(#:}u銰	t:UE(eh8RaM^4͹SԷtgy6ݹTweɜUXA+h'G9{g;rtfd(v
A^
Dg)5J4 GzGя!q=8LUd#M#oy8I;p;xFUi撬PK
h<䇙@/org/junit/internal/ArrayComparisonFailure.classTmS[U~nIIZ[!	%oR(55JZ+!9	
sM_WT'?OQs"0cfgw{_D-9s]#XS܋K=cΈ1|h.=XƊ>2Xa~
Z
e@׽GE@BBEYk.~B V{e]RC[6B]ttՓaWcn5Uy/TUfrqY2$ye-W=ZYCu}5=ܘ8rz`>U,OV(7jzH2D}	75~5`֬f;'kyߗ,ԷwԽ%k9ۯz*^Y='yWˋz[yf0aˊWUOMD$r"J6:U"<ςdhq6VV1-BXo]1ZԒ6ݎҔArgZg3lq5b.;.s.O)W
*±Tc2S5E1(9(PD1[uҕcn	$O[%	35ycV+	;/{`$onlR3QzRvEE0MAVXdU=K[TBQSCNiOuy"&7Ͽ@UB&(ަ!kWטܷaHTa'Z|GGwqLEbdЮ
AGF&(|FլS27:27hs-PK
hEy۵["mګJs+oזZv*`:wZkn
zqMCEmIߵⴷ֠ts}<ۚaM˶P\fn*:[/η|ۭO<Ź*+>T})ae;m_M5oٞ[}!4hZVU2MVEk?+fӪg;AĻꒊH*}tDNE6$a70>/	 @rZ]S輐A=ʰvvvm
~ʎ\nT)LyW䌭eSZ&P0c&@)m|jbgu6>7&ΘxF_!LXX6q%kb
	[t鯭fm;6VY0=&S	Nfjjҗ|kv,B^cCk]6=Q]hH=^3yXhy!K`8]p]‘lo~fZddfU#z[3ЁAmIO{X#ڳ.Q6=];2}Gu(3kGE9y*r݄x@bGq(Eeqy?B{:F!	-`R&hd<%v>{xI/MHl\JOرl)'iog*8wcs1My}Lb\B5qbw'z؏0491[x
8kfEj籂Pr^4sb/wk"T 	*+|;VIXTUܡ1In<ȸSk4%?!>.IL)J#%[URKx}`wB9a5
|D&9Kbsݠ[PK
h<.$org/junit/internal/JUnitSystem.classM
@Dg5&;;A!h%\H༈G+1|Xa` %D|7A,guYM+YkBZΗ1
f5x\˾OX8_dFdh[å2<!BHzPK
h<_SM#org/junit/internal/RealSystem.class}PMO@BVAP7ƳLFR7MiWE2*/oޛ73ݏϷw{hȡf"M[::SC2hd(Yʓgd$+1rX-ܡT<ު)C1w"e	_JӢW!A؉	듫_t-G	|~ yg߷A璸lᬔlsdXIdˬIxDyy^2{L _lǗe
_j5_PسBd`ҰJe61`;U
("RXUZϖӯeGfpƴ/~ӘXf*0N;s)@$2CLbݡ–}Ӕ;RX !ᩲWؾeLwM`z
7dɰrLe/gVtNYp%2w
육Q;XsfA|`§m5
t3d"lr`z^\
#g&vl_db|UI˶f4)=r%B -x|\M?=;tJa-׹lH"GLgCQJ;1	x8&+hX{C/a&qn
}t.ĜHug*W&τZ.o `[NB?mp)f|p70pM=l7Dq|l@N|R9YS|t:+`+l  A#Rف,SwsƳ,y7Уmb/!A/-'lOq
nY%WqwH/v*\ARxGپxbv_jUt^߿% ,gdl.6KeԞglE2
(cS~64>j-;W#"HOӴfgyiT3
94浿mܾtyYv,p8֜;AZ+)ebq'G[}/DsYKxjP6uk(
5܀u ,)6^nA!ϐK[Z*p*o!|Ck\G	5PK
h>>PJx0kS.!e\nJHJ.$r!Y
O_սy2!$dEKGY*&iREcy2䋶	I1,Ow,T*uWY4e}WCuawCnn	nYS%SsiLq_FSLS||mۆŒ6FUk]&`-!2pH3Le<=C]\bG	aH!
ףՑ}(ÝP==ö\sس4vJW~2}W_6`d{mMm'5˲=wW_A(	JaLc=!md3ݩ%vݩR[3͋$<>qo2ܑ{2Ǣ9xE|!K|%P+ؑcWj2\Xj?ONxKCeP^i6-c8ݺi5qއ8SQ7jn*zգ+S5Ԃ]QdOncn-Xܒѫ!Xd	ڮѿs>/BvcIPtӗHqƷhV@),wGYoӘ=!a^C]&Tz1+d1"(/ùԲ@"#$j9JBT"⫓/!1^b.҇sBZxSstwDӑ|'y`h(iTIeI/bGJ"!&0!mc
B8
4fIwinট[4.w4d4c>?a0x+OPDjJ,Hħ;MjmNk'zC!ΒLU&[m,]z_PK
h<`4]	2org/junit/internal/builders/AnnotatedBuilder.classVYWF
$"& ąljR'i{@8ZH_EiI6O}	f_>w2Y'qO´	3	D1+澄9\2@BN—vQKx$c	e+	Ws|i$V(~P,sP\_cH.fֶVڞaٖ閷>V7<7M0L,ζ[9eqj&7b;RY2wI3rd`Y6,kY7L.+;Xו1jS-㎥F-to6{Scîm'g.%Lpfm SN^=-Ab>5Së(_!8v63'2/P{"+a:)ۖhm Dy8g~;	bEvڞzc-yW+ܫڛ
93z
F̪(Ir
_4Ķ<\S"!\Uv[A
FQ-Lљ?шhL{x(XS+gt0i&|2C,%RiDZzvM
]Պ[}sS\=4*jE7_lG}I	T@g
`[Ӌ=C&)qtmsoeLv45͉֚Qt:ٟJrtS\0Ýs8|ˤ-Z(ȹ4?\jeX+RWZv7.-۩ýT{[7^}00%U/hHnhHkLD~
ӳ|A1Ir0
JY&"r$ۏ!bo]=8D;ZeT@$NP='JaFT(AILV!MhK&9FIc};H	T:%Zt$o8g
k9Ft
xݧȑttO@O9ɉ5|]Z%Yn&U"ϑ}hdÇ'F+M gA.ImR;I$HPK
h<D2p0org/junit/internal/builders/IgnoredBuilder.classR]KA=l]O8|SBC->NaYglʾTh}*s9̹w?F<O<Q}m; T6q:P6]~S%\Y}t~?,Vݙ;yBB:(I=B({Df9HEQGE`SRo1	V|ۜީteec&syϵv,zyK$:9x
2N7h1ro34OC:<_]a,L1t[sAG*1r,DEDleU[2&¼PCeXo2'ҍ-@
Z+x4VKLmD-Mg0Zأˉ6XؖyZp#4T`<~25ݧ!IP$=ekyG@(UDIPf4ࡼP	$>BnJ){fsΜ_lt`ᖅeyܶp]Xg>Cq]2`;v+]x>e;\IϒhOjV7TCo?&!OP~,]5?Ok%PP}Zy0Z/Ŵ{#Zb2:tpdzs a-I[Ŋ(ޔ5;G-%#uqU鋳j :2=4p\\U39D;f
N8{ms-,4]n/aery몧07XH2\ZQm_s\+9iJ(8*$bȜ0GXm!ߴQ8bGI'#U"	UHHRZ&iLE5XJ]n"c`(ȖqbrwY5'э?PK
h<	{Փ/org/junit/internal/builders/JUnit4Builder.classRJ@=} *o>HQp)8C;5Nd>	
~%LZ{sN3U̹	L:r0͐PZRʐ$C_Ei]Ԥ95*.0*b.laoEdĕHyg|k[Ik"Ͷ'/*-q%'tzcB6 LmJNo/߻IX$sSu`TC02$mŚs宲Cvتy8y"_J,c,CfXh[&?xCG;n:/Qqbؽ.КE^;!Y+>XxBt;J_zA1!1C?|ǕABCs1b[)h
PK
h<lk-org/junit/internal/builders/NullBuilder.classQKO1ʊɃ x p/K%K>L<Q邈{773m?>
NÁ
6H6A@RZވvp6φBs0-L`"|Վtb#*TbC!G\JyH2:T붧[(tQԘFX}߂N"z3wB %"P{&Qk"߹yt<m8&ꉱbAQB2sz^]fbnҗQ,H8C8ۜ~\\?k'{07Sb&MbF+lMF`
vЦvG[bFCהHY^TJAUW0cl/@1BKGQPK
hьuۖ<;"lwqae΍E\03$<颵*Cayzž~Di=+^3~tsfN˝rZMt}a99+x1QK|`rt^7,#h}%CdԐ3:
dBHdA6Fh!jC9ea%I#
O*,Ei#JqKrS&tBn $|"n^l.$?G9BzgD_rٗ^L~ȐEIaJh2aM}a=`a;Cfe-z֛ќQ1ӲuIT>ަp0
ga61my!kj
qAh2h.^Ea:mV?EmjV`v1Y'Q{boy*=n{*\qzI/GrIom-nR)!>y,xxW{jJ (M{0ٍŨrC9T,q7<ԧG @*wccDslq-'aܗ0%Mn%tKuw3PK
h<\> d(org/junit/internal/matchers/Each$1.classSmOA~Z8\E+VrK LH`ݦ]?/&(H4vvggyf?E3Yd 
3PǪ><4fa_澿^: l;sCݎ7洩T<ހ[Rx\szĐ	+(ÒPQ
lT%8
jأ
-7 $Q1*X'?g$|3V
NPm9aZި:l/||o4MT(8W#tIᩈ&]bT틷ks%'l,+h"M&j̆?*79=A
1ZSzv
$#$7D~oI`7Dˆ~zqC6^t!ZQo~")TutʮCh0^T?b~C)$~?v%!KhIǤԀJVOx<PgZp~M?eI[ZG,溎xW빓]!z!oɀF>4y
HuGQ?:]@d-(NUicX!رKKgk^6yEG躖y3^qGFT(c;Q_!v)!"S)S)S'uYx"Tx
	iZqiV*^dCSx)[].Mq%7h%8z=(b#7tE}!	o¬O$GOz&BSz]4˷PK
h<̜0org/junit/internal/matchers/StringContains.classn@Mܸ6&mP(4,eHR	Hpqd+gupHJ <bݙf'hpa
W}\4ᓽ&CmS*;.a t&`cl;a+xV"{	y4Igvl"S<	G\C喾*ͥ7`AOoNi5A&e|0Z;Ym>	Y
Q\OLˑ(DwΜy՜y?0$?\(cqF]Q^PK
h<&k2org/junit/internal/matchers/SubstringMatcher.classS[OA=]vXEx)-]DCӴ!m%|1Q>QoK+Mf绝ߟa݂G&RZt,"BJx<%8I*y-'I8~
c%ߠ`T~V2{NhG[
j
[䙉f.1F6{&^(xPK
h<18q1org/junit/internal/matchers/TypeSafeMatcher.classTrE=cz}ۉ1mCLbqb!	jlKZ	DQE%PN
T#Eb*/;3=Ow?05D&*nJ˚[X*
6~Lkxy(ʈMyᮊ{*cWty|
{ƗFf;ٵ8%k6ܦ ۟K)dn.wJ60Ēmqw+{a5!,Mβ-7JFG
7
eR#xa-CXwr

kPֲ].l'+tHNvb?[zU KݶzG=KH*LSAeC9T6
>KnL׶hԽ\Fr^=!,>b@3L!09<,:_s,ct}Oʏd}iUkt;YZtXhդb	YfGh.d&3LjOe%Ŀå?z1CK?|S@B?>o-fdJe則d	yTK)1`T"K;IoU^BYj1Fq'ʷ7P#(GmYGĻlޤ^	XXPoIeN/R7ҤH|]\͵|r)F5I&2v4mńڊF!ޢkam7⭫PK
h<'4.org/junit/internal/requests/ClassRequest.classRn@=11n\Z8P*APMD6&bl	$>B̮"ٙ׷`D\MnncbwUg6d0""RK
]9yw١W&2E|C~[2aX琏v0 bGE'R}P%t:A8rOv	R32k>5$+Zuuލ*/|Cu
#'/BU9?U7m\$a_J%4eKa[XceK(k%0rx31H'c)i_!,l>k;T9C
gؼ`}\	6-OAYo
(R'7tf,:c0uvg=XXF"%.R\F*kXA
Y]өAOW(&:!L\V''CrcΈM] Ot!4&g495ʮ:EEX&Xx|Av<0>qE#
MBV&t7oPK
h<\Y׸/org/junit/internal/requests/FilterRequest.classTR@^H\ h/HDE
:8Cf:JCZ¤Iݤ^GFr<(Rݳ|/o?b]A
&'y2%ܗ0#A@ƬHA7<Ƽ(T‚gru|4=at,_M1-2HuMpbX]wF}uVė,Yf(d.|bmh1E17ɷMT5t{[8ΨkyCxT
[WCʉo1eð1o7-Y-ga6Itױ*1"qKx0?Z'=ms.-vFW_֝7}H6t]]*"w2왆b+*^`EK(x%C*`LbLo4]BwLV,sAPWr"Ͱf'l {Q,M>,@YRBQѻSZ#\]D>AZQ?c
 eit	[Âm0/:DHk$X~xrJ}Gw9"nVW!yC!Fvzqn&i2aO4
a4~PK
h5P%quvv4H4gElh<3}_x"
* ;5}cȡɐ?>1;{DӉRB{.A8qj$wBW-,ڻT|-Xjw,I3IFs=zRVCQ&Ϥa\yǐtA\sW&QpCj'im9h!R3Ӎ!0",:	{/zǔ=f)f/0,h>FWl4%m"OD4*=Cvl/`Uc[#;"xLab2YCIYw?#uL+Ocu\mXJlҨ'4D&nh۶o'PK
hW:k?p21T1V%ǂiٙkrJ1>50Tt
nڜƊ>efڐicz֪`-5nJKG2:NcP8Nx::qJŪ
N߂~	E5_1"˴}Qᡠ⁎xⱎo-KuQel-Ew#
B`BAS.҃N㇭MVCUFk&^9\Z)feyoԩL`,c^
XVygCCb8Drb,9'']f[KJ*
FX,=|oUU%Q›=_[wa2۟w@ёDSJʾ$$]\yzS(M}76Q!ueQzZj6Z{EM>*rO_r7@or?!}oΑ
~-jVuMwr9}k!3$xi)ޭLfy_3TR	FKo!BH}/6P~f	ʵ∤E'4b1Fo%=N%Iej@LLtPi{MBn>
R}ШWs󖂿Wiͷ_pw-/<ő8K
<80aJ0C3O;JOhGl1TGwlPYG?zAcb90pK3|̷fN*!&ɑm! Z+(I- A"|vͤ,˲ZfiU]APK
h<'*gP5org/junit/internal/runners/ErrorReportingRunner.classVkWWݓ&#0hRZE@:/oUתjѵ/j<0te1{4\v\œx\VPH"VY𱊫:qM'qMqCh~3|
Rl,XTS@]N[]TЕY-833
ڲΊk%V0`+|nY,yV^Ԥ
fa:N0`<`4UDtǵJ7m^Sx9p tWÙؾkL亶_4_yǕHcX"f;&V*um4ywU|[
Gw8?Q/9,4&E%B9߶;[r{ˋk;vlNJ7F)Uo24VHTWtp)EГ-j"w$g}ߺéj˹&o4bk⣯̸&>{	_"[v|#X~`SQu6cjJ9OV1o/q
AB(sTGQr}QczaLl"G1go^`0JPb5IZ%)0z_X'_yǞU'PqO62&7mR!ıA(a'(Fp҆BqB;S5k_cL6*!08@ geX1WCXi'Nž{Ѝ:XwC{):7%mbm!>FOa2JD]:#Lk5ş_VtZֱR7Ǜ'$h;%zUxOSgD]uH
ҩMLn1 `)[㸟`ZYv6H[km%pOZ
ʂG)MKPK
h|7;c$K_ܥJiMvhjofuAPK
h<5org/junit/internal/runners/JUnit38ClassRunner$1.classA
0Eh5Zs­ƽ((xXCM		$s<֥+g{O)⓭\&7JKxw6\,WZxn^ &+eyW[
L)&/i@HhF5kar~2+	hjFP:FjPK
hBDl%&@!UDSUNELxo0$'`:Iޓ%OL1r8]jc;Yu<04A'B wIIFϔn1=~H
7B&/21@^#152!ZS"JMeڸ
˔!e+&*S)sI9re60z4$sS@ʇ!(mU1ݡ3
BkߡPهV^~C~hSB*Qv0@D*Ioc``L"lxJe&튤54'Rӄ
xuSBqtsػ~ɻ(VC+aiϾdIIG}0)aا$@} ]!h@{Q[QJYjluᑬXBEO$bPK
h<ԈF(i3org/junit/internal/runners/JUnit38ClassRunner.classWC~faw٩Q,+&DEM1
xشv]vάhCMm46jmaY~{yo>lƿtgpڀ3RM񜁨y^V/l𢎗,y\0/ᢁ/uQ^|Y%|E(5پUoXBz[c[Fo&1lwd}?!VQ?c?wf[.gZڮ)59vlriK
Kۏs+X|xJ;4Dv:Po?fRY+ןRv4Pٚ;98kZYRi+{*8ހCRBS
&>G4bkg&b&	E2ְ^^GLyħ0bbc:x7Lսz"]R~c&n-n߱;ޫLt&o6p4
'5,@1;?F7@:M2Z'&/(UL0O	e&bq7ef
μvك+6G]b޴i,s)s9KǬLfb)#KMNԔ`F?^9x)>Yb.[e'7u:d3*C\.Igl-ܝo|eBm}htU~/14Vh
Cp7ՖQ)6Υxw _f<+O;!XoMդ[.5q$\K74/AhEΧXE5>\-`'>.$FI\u.' 4m	bǰ*0:Hׄ^1^.dM,}-VY-\|u͵,E#GFPw.]6a,XAH+c
cX=OְiF$}L~v98c % 8Wgy\@CAy&w نU8Ha/>[yBDl1pQmwX?E*u޴|Iag[VVڞDCcGԏa}wOeRYM<<3)*7m@-:rrK$}`0jeu:N<+8c$?Mo4/0#HJe@ʀ'6Nx|;ef=fom
[XG~#|GR2da$Znh-CwlD&8#2k9-)7cjg7:2G/|9q}HtNoRP7aޢpʳ]2ޮO >Ã
>|_2`-5ά{
y|byMll|?C?cKPGGƣ#1	UGcZ(nP6H(7"7u	miuXL}4[!ֆ.BU#MQs,t$1t3Cf<Xȅ#tIXO[%#$Keus@;LΦ7{G.:a")Gm3dPd٢tAaLJIˈFb2~"aqbǺ-ӭZ2]ґǴ1Y$bqTNA{;jkshO*4Q,#ăe"Q55V7Dk)-8+	@%k[z	ͭ"0TivޮdžMCEdy<M.Wnd0wktzVcGp=͂d&8iD&æN>xITcѣlLI&0NkB(IjOz#^,UM6ˣMsƃQ	OOvGƁq3:ŵ@6	)0ejIs`JY9;Z:rGv:CgRèJaiow"WH2aFKMhc2v
@0JSaVg)y*/FTTvT%11/Cs+87i 7.7:iHQqun]4u{Nz:	}Ј)ncg^VPGnnYf|XXkE
d݆}Zd9p0Mڍ0Z<e@&j}eL1joiv}u4ˁ|@
*݈q=O]xY}m_K4rH(G}<ϛgT,JL}"z,		>nVҌEZK']<_s/-MfӹP$Y
1i(	A=R!,(v!bG:
ijR2C̎,`CAh4eudso#De1E
DJv$܁:Jxu}vRoK2[@F"|%TYtct 0͎ͮ?
!&h
՟e,B";"-mOk
֓'&ԥ[O62n7~;(rSZ(VY
KBc&u"En;>~F8_VZ
	\]=U0s!1	,Ot,g6XdyT:dI@F	}Klcum|YZ:3mӠ3Ŀ8VRJS	%J)PIZM麌n9\3%G!DѺfСT S8!<
-¿qZLl<
y[o2G09%:!V&jYc?Ns)I@4KP$fSx
6x5Ahbl2{Ys:78/8\0r2:nM*m6q&cR-PK
hdF,?Sx%7f^<1gNv}˩4
XŚPĐoU1Jĸ`}{?G?	9?бCMUXZ
K']B"0 .Ɉ7\|Ȉ-۶|"
fk}7)
yKůX-ʢy'xf[ kVP]9rQ`4;%	VL8 IH&SX˭E,J"u$)ST}[K~5wvjSvLѭ`e5frk@8o3bTxÎW7Sݞ:6>^(ahG#_
F)lڜ$Eo{'2>'\5P_{sPK
h<t/org/junit/internal/runners/MethodRoadie$2.classRJ@=FT])؋E(UmvK@_ٴ>63sΞ	0faVabĖm٨'1C]?P2rDDw";R\RRaqjV`T`XI%/-4x#$Wk@450طZ0T=pJfTXGō֣>dZ=?;,ر
)i!Okjv=C/]xՉ5&
Pf
dՠ)ӄG{'M"t3k*W>_H=6EbQ|B摅A9*}"9[r}H4X;LA?*EFPK
hx "ib&1CPhlM$hkyK78Kvquij%i^l.fh$Jmmf7?{fl3w9s{y/:LJM-Ani>$͇}>=W~A;!<1*qyD)2'uf
DȚp4}=flJHydZ`ΆLؑ"b&%zVE@v>aM	+^u>,8|˅=n0FZ	c|)֝iRpv^}d,d\J
FbVH"P#q;SnjN61nl;KNjp^K^ƴJ
gcĽ,\}됥3iax`oL!
I R2/}˜&Bh2;a+OiMoe_n'q5GyX,Jr,;v$,j!լ6[~)3?/R6NH,5+Z+Ko5ձgZV2?b[okWwYGŸu_q[9`v-nxKÚ+7ũ}q62EJ&/;1萀aUbn#%(\K֬־S-bt"#H5^vyUe0x"^9RέG"\lf+"PZ<']͑I2)7ۤHS7ޢ\%uQx)V'wtv6T&1AODyM@5L]pV^t	2Hn}-ϟV[Ydr*vY5dƻQyrTWuzp$Vfu_A<$XPwuc؞m6

=Eu_Cp땭LZkUKN($F(a*
3e\$1JqI~e`.'ib@ç>⚎:0AI̫ݗi,+iԱcYұcE`hqpA`4W޵VvbRmIʵhS5{IH٫͇sǨ;N +{~ڍrPݴuX	eE;VI`pO8ӗ]`x^}<_X ޸c]:ndNõȧKOQ
φ2}o@>嶢mޗO=Ϫѓy}ݔZuPSTЛm2[qBdm'uRQ=K&Xe_k(`MǺ{Ž$]k5q3r[Wf؀\,0ڏpjSN!V7divo<&6Q0\#N\u?NmGx"5{Foou,=N͓g;SemR<>`NP{n5(v"g֨D=$~|h%(ӡ6	Kre!c뽀Vǔ71,Q?0͗x30&x<5S(>8o<0o#y@w@l{k2k\?Gqooi\EYT
#h--=3#CN`ů>ˢ/ȬͶ0rW&԰I(>@
^%%Z!ۤX!1^y9cJ@w8]`X4DqoŻPK
h<8T*org/junit/internal/runners/TestClass.classW[wU*ݝn*	$$Bd-PBQ$DD.ҩ$P]8fxq.a֬fZd/@ΩtpRu>|]&]Oa+Ω8;b^ŽC)Dp:GA8b$.+b8^/TRྫྷ!|U(.+,VWkx,)h
cz&[)گ 6aZ[pW&8hZ;ޓ
#4o1^2I}*GI똝s'u{_vLcvf3
DΘk882|fȻ%#=;./J-k5\upibze̼K;k13n/'AcvBƸ\eٮӁuVE\.eyf8X(輽̸8
6]S)gXTR(h0PKDŽ!A+? uvx줯29X,uǀE?NZb܍Ɇ6?i/Lm׵
?ոӧ
ֺεc\9r]`?|Gz'b$ق M@&
#S$[-;~٧T|`5?2ֈ꺘+#wB
~-h+TD5DQ*~
t͛=A5?mUJcVVy{\JeuLkV86a1jaޝB&+&ĉI3ory*s|gG
c#_Ѱ{XҲԛYS[
N5Lb?ix
xCÛ-iUV4wCQixK4w9V{XRvH5L!_4untZFr9+eYLr"[˧D5`5m?+hzJɥ9=?n\r%-Ts^@ylNw*]=k~P~=:i򵽧/w{9;'8̯EVMV3JFBAU#ut'yuz4^պ@aGmAyv
Pr(hzlH NİuxH"UZq-=Iw`o'W<[[Dm@[REp
g]'Rgۚ8ic
E'GbQ93+K&?B
b"`SS\h
D@8.y 4&oUC{v:L4GbXx":XzAK'F[,o2%OЖ ^?}$k5:zLSy/Pe>^b,0#&ìQc`d?3JQFh15xÒEcqP2&+!fPp>jy7y:hRc4T6~
M)Ɉv#pF*XhY,$??~
|1w:]]ޮRy;T"{	Xm2!aXi}3ۃܥ?"Wi'y"<qtHME$!}͔x'.)Oɧ,Ho7.A^yjMkI2c?!F+$ڎ1vh(NQydM'Ko)Vj+lH/4h%J8񚉵O^
d}<>v0'i-NfzZ݁֩@^O^xן,/TDrbh?gi>s<^2]f
Hո)>HTe5NaZjiPK
h]:
™vFf&z`WtCs2nT.'TP"^ijܯP5AKB]$?E
e=sfIcv]|&D@Kݠ:@B+{+E`ouӮ2PRR,·D^b]
>>*GIPK
h7org/junit/internal/runners/model/EachTestNotifier.classUmWE~&IٲYMVZP@ZmhmAѐj(zΒLpݞ}+9NO/Ww&KDܝs{?7e#qHqS-n:>N>I.IaE~*
>bUϥBCE`)P޶:"0qg:nus``4qQ9tPɟxB!umppx5ކe&[q]D}+)O|'H1h">_fygΙw9so%VuLNC݀c`
7Fc)_QCH`x1bzYD(
'[MݦuCځH
LZ־ݵ(|mSC*PzA`>Y_(,Wi@>I7d6{Ϻ7YЛ0j[	]hFIЧM@}Zu|)޵dG"X;HKzA-uU~s#iziw̾pbaJ5Np6E0Yp-œ۸c.W\75e?_iFUSq#7䯍{+RӍ-
\.p&j0Y]E91s9™.ˬn}ĈC1]!}cD	'xؙ`#P]β+PK
h<d	9org/junit/internal/runners/model/ReflectiveCallable.classQ[OA=nwq[[+q	N	фd	6OXYft[Y	2*I6z]ϛ[XKc9E
+	VST,/ƚ@ucD /hVf>unBVT~$f(.+\_F$ƖYK7V<#a.\J3*}[#
X\پ<cR範 옓xeM:u	^
~gb>#ӟ_`߹
$k`-Wx-?Ω+.&o3ʽ3N{:=~/G$m}F2Acj&ZD#z5*W5NIK!|!r(g5[PK
h<0Q`;org/junit/internal/runners/statements/ExpectException.classT]SV=6(JLg4q'ipc7a.,y$HK?3Sfwzht={p?ǽ!Z(YǘPǽ8(YT/2y/hX14,ű#5|[n\i:V#=?_wf 	-˥sۦS/ڦ+Ū9f@洿0cY}{-犌,X.
̦G}u"O	$J#VUzdɭYJ?6ƂO4	v6l-.UrN,5.wMPhZ}=	Xc|Uu
[\'K+nӫeK=Մ+@34<5%

"0q҅eoIOƚkJvr`;|oTXc1R{_ Ue[uM`5S%s.^)?8פϻ>)ies񼖚A tߧ{K21哐eϭP[%t8q*u5
sjȞT<{qq#|8c%՘AjhW~Sޠ%e2=N  (Rax"pO /GۄcFIױ(v	ơ?./fV~T[~J-\P%.-$Gޘ򻫿yް."=C
6FԮ;A"~װ7xg@5$KϠSN5	,#if &EDZrsPK
hCb88"܏33=q|f>ʨ0#9sjk&W&m,RdQJKGآWXǣsjA,-Z@sɆmvH\A
u嚼@9x+W)k$dviňPK
h<#evN;org/junit/internal/runners/statements/FailOnTimeout$1.classTn@=ۘ1.
&hC\N
J<4jmUO>BZJHHݳ3gxg_WMlY3q_-L0M^I!o^1tp,V=ćtv,!?r}Hun4d0|7q,򢈀ր(m-Qur7jQYg&? L#_L%mA5S~RMދdMҟ;|$QM51wլᶎ>>PÇXְcwuXSYE=
.U\ouuGz~㶤]f ;	vHKXHW-we놀֮zte|`m){-IM@pGj%
W,Gw;ҫ)2Ɋ4Yjی/p9v	v?/VCLݥ@4$]O-~ EMC`jrM5lpm6J@#;~$BiQhb[8a[TlhlC{%/WݮהVDx
Ŵb^fS n9Bܖl8?w5!Z`.~Qʐ,c6sXm:-v	xc{O6
_K
_DCE251->B*$.psĶ$W]8c\UeË>vXqBuFQ<.0WRD:f6Vtŋ;wdJ5<ɢdƥAl:fI?j`&UFTW-Ngc^ī_>Gɋ||G!u=1"Ydx!(
 ](%e\U"?EbJB#Z<{
}so06	'{{Nex<9E+0?ě+`V~D#G2FhLy(ܑ<-D?
$u#y7BqVN"AA4*k9/PK
h<(O&5org/junit/internal/runners/statements/RunAfters.classTSU$dCX֏J!"(*P@	M}Y.fC;g;iE0ߜq;|GT{Ϲ9_עh@#ZZ^Ukh@0#J{	S5LD㢆I圊bojpIaiVnz]NlK%ۖn1,J+OIЖ,oͬF2UY(Ǘ<8UvӮ&o:VQF

$NPJ5'c-ӖK:Ú3\S+Ɛb}қ6onVbbj.Cwب0*vN^MV|BUbx`Bl~un
եQX:qVy^@ٗȇ9jt]GsصW3,utl朒[Ӧ~:,t#	utq򌻮ixK
PKY
:.㊎NNx[G)qjёǻt=#rWK.nVLtoOq+X~J8.ﳵӇӦܐSS47%08T֋4oNU?W$[w/&`G#i3-1O$YWo˳S׉"OF{>}/H=]d܇Ӈ^+%V93gf7ߜ|00!7#m۸	b@
%2f,{p53Mn;ZZㆶ./qӝbP+]Ϭe]3t̮gy޲Z{0p|otYLl0u=^[ݢ65Cӂg'4zUy1dɗR+z~VN7Vu[Qv;V^.M88+Ϭ2Ce3`\ָ
UR;O٬sϋPz6%^
3HI@fH;7CH1tx]&_l~;7]alyv/#ֆ*:ѫ-*hWъ6*aFcOTEGt*L-2\t=CQ͕mmUf|r|DE#:x^VQw*_5
_}kmfۛ27v&ox&_G
fDZܟP i\ pu$IdG3Xz` _h2ɔ)J)O;Y5]kZ@AQ@IX$t|,T=dW1HD40df)
wD+K_G?Gn
1AІ8i>nJ p"cTP&dh|PK
h؀wa'1NF{_D`^-vn,n7wlߋ]ra`&i}7!>:w6KC`&t{|!+ydO?RD@R'f{L'G
~zPK
h<ѩ&org/junit/rules/ErrorCollector$1.classS]o0=^CC@Vύ1
鶬T	UEBtajR9i~?
qmZE"_{m6TP}m$&/䀫XOu
Mx	ToS
&FsZ͜އPcf6֩{0y(noJJSq2
D]n1dB*,-qSJ0YwDC.6.*p\uQŖgaHٖ0\*Gۏ8h56zg^*qhNһ
\FtA&*CVGk4ܢ&`s%3O@Lh)ɺf\:uͥȣnl/f0ׇ۸ni܇xy1CVHIawcVm?g]\R0wK-V[2yeKke1Ɛx_ڮx66)(`ճƥnѪ'퐈L:7̊8
<
ic/N`{.9fe8a$JTzDNDPV]Xoju0LӼئ:oXR˘y;a?NZ#F2$3D)LV#DTJ-dd^
-KM*vܖZ
wI1ҙpPRB2tDDU/Xܡ-6:pL=QXD2Rvoܱ0ˮ+d/|䙎"&5TuSe8=5~'`MM_B!
S\	q"l1)2Xh4uCF}-#YMbxf63{gv-5	t)CMJ,}_
5ui4>X;RHBCK`ixIfpR-([/0h59NGrXb"bED.J+l=@ޯ>Cg#,)eJE
KT't-I9ڝTBK\W1MK3]5WBapM%rv!L;gȣCZiUZ^.x`
PЎN1\2;WNTj%1^*X%,*X0Cwm
nUΚ!N0]I5w.a"yAQ_tZ/*"תUn|Oy|tv׳gT渹Y.ewݞd 
7,\$%R::D=SqP$D_'*whZ3`Hh*RCm+}R8p-̀-%{3]#\.4.Q!Yݩmcmy,eD
Դ[Llz.ԚЭC:Щ!!
^jW5O={4y{Jrr%r#"/"Y!
,hXĒ\R2\#ЕpӰ]aܧ *Q0=To3=Iᓳ{c=o2;ӘKCQ,r'0qXI%?dfozVpQYinoUe+0ݠ]ƐhV"4襵who'h![ަf%'*O~z(GGp@źG%$1;+Z~@Lv_hN'j!ݚcGmujG>:9y](P\'p(&rц"0#(a;r]Zu2J_"~.*/PK
hKཱྀ!L=U~QrԊ(/W|2('0z%,EOyȠ)kRvmW(tJFa0\JݚcW(9w҇lGݭU۔
E6U.
gFܢlI0'mz^coUIEjXɪzz߯,t0Ol'(/U
_f`-K_=|WR`}ҦP_jlJ/&p_]lK޷Vm8+>oXnPMW@y4rn`;,i}s
c+.Q7Tt@Ru>\fUy"l~G74!א9\#}xt8y;WC
qnu6&q'V<f
:g|5
4^0a& )3Cbϐb0ߧIG52J4LoIa&v^n<GfiV(#OgOgHhz>ɋ&QA<еqUB?o:D91um"zAtýo30ynNw.Ђ:EqFC,dG0aToKvdZh1wlK#MxHL4=PK
h<3jF(org/junit/rules/ExternalResource$1.classR]oQ=(Kץ`J*T
kM/
&m~ⲋK[1>75AQsglrgΜ9wf}6Z0pOMjx ;^͑vgƾUHy~,c5T~#nT{$Pn*ZE8*~2TY}6|]:
W/CGY]3
@zsz2=j|>Q~d!ر1뚎\]m[y"Iw r#uhX"LyZhjQbll3&pM=~NS^`AF;9_^(4LE3P]Nvsq&ew*ujvT{xX.zL.4>OE,*,cO<4[tj#%2TK,Lnwf9	J?bYp
}	-b
߈T!:mI|kLF
$PK
h<
J&org/junit/rules/ExternalResource.classRn@=81@KKmS$R
RZEqn״Bn,..Q⇙3㣊paÖCYF9C3D0,uTɓPctҕ{qQ1lu㜈"εP){"CO&GOi*T$tkiE"Rݙ	9T<gR-Htc1Op,Z<ka6wY5iB.i81ёL3ƦSΏqyCY+<PePN&n`hK]{%О
S-
VT
!o8uIӿN1]~7(x"fPK
h<|Ȧ org/junit/rules/MethodRule.classA@_b	ؘXwUE'AMgv+p( xy/߻/WStc1:HV:Σ؍(9alkQ5+;d풟HjeGc3v[NBPRo|Y%?^n]qSLdxOZ	M hB!YPK
hpSͷp[Q5pO p	VX,veۑ/A>8>dr,HM>@sp:QP(4C/:#Ml%RA+
Z8gj=,Y0YcR'yi{qcCgqj|V0cdüZ9b@yFa&wI[DM;x!(1
'=VP:J*Q"Mz HL}`\}='s\fsSOz;,	bQʯ)eiVP
c&y2%H	l9J5DMF%??E?ؑ|223ԍWPK
hc|&>Ȼ?B*f9gm?EhTB&rԨQI44ҘN,ۗn%0Qk94=OkZ ц5*k#"FPwUhm0z/#ސ|lQQhvm8)\PxmQSU}[2p\		@X>\іQL1V{{(ֲ@r_ZvzKlz/;~ٳ]?tӘ1zgnF~xh+n6][iVN:ޞIs?I*okl3a$(]߷.fæm+2鰮aj[wWw`o ӣ1gyՏAE$Y<0K0'0"yk8$1]'JRМ{yDG8A'YIfml+]:-]/("y:/b!g!ȑNtiSA#\J9R7D:!ڕX,Nh?x,1xڅPK
h9u}b"Jd\7,]wZPNzVGdA:yd+?P?<@[q`QXЫe
Vq2&֐':n<64\V`GnNxFUW5Clg2l=zF|a?ٲ_PK
h.wֻQNLZf@%2]RmA6	j4=ұ"R~WS0CɁk'}גBa6/Jr#Cv ;ʗ^aKXdxWN'z1Pzϔ$>!ڌ/aXpk<~ܻ6}c<^zؤƊd.\Cq(7QZ`ܠnbئ'7h,a(vW%gTLx#|9k
Z+uB)86~PK
h<_| org/junit/rules/Verifier$1.classRQOA-=8ZAbUJO)`@bR[]g`?e=0ć^3|\TКG.lXrĦa~ʕ`hw,ih8&	D(8cC/JW"	{ȏRRu8m~=>l!+]qF5Xཱུ5OAHC݃ϑRlj$ e2PXL$r"wGJ'2P8xa.=c5k 0+
êm*ѧWoe㓉:cҙA”CTOW7mAZbgؠthZK	 OY%/Og(Q'V́1pߡU!.-zohgP@M&kSps븟cM<*E."~PK
hN4t?쬶!}*QIJ5;wsϜwC\,{a'.>3e$C\i08{`H|KæPt=n4`0,c)*
D7?P5?g(*C'kH2!"Vgzs?Q슖UF'M6cEEƱi8Cvx[e%.(?S:ϿMCQ7r[`(a{Ouaut85fO;*迀rݏqU84zytV()Pހ]$Ƣ]\8>o19(>&Zw܏
WC+G
l
쾇iP=s0GrKa_cyhKhm@#PK
hCULNzA~&yסj0QroOJJX
PK
hC(SecaUWRɒ,
E*ׁ1h6CdZMԥ@jEv#[%ΰ޹1T9kWӏ	t|Td]1rQWl{o!'ORa2|ii8]@:Pێf4ǵeU#mCyRKisT#Z'ի󿢥Z
P1}iCNvvvF̂ۈe#jݓݘZIňT]Bkv]Bu!ՈioRӪBPbb+(=U4jZF(?8EjUz4TSF.|&;-Im1ږRkF1$\w-(U]{ߞ HeƏe]2~J؆w8leͦeWqvxegn*5~y?`\NYo&q_nJƯo;*J,	<o2Rq":ve	B;1G϶)x:)&l*Jf'UGS޲7#dA	^.c>M'"KxG*.|96V.(NPJ
PK/ײUvNNj%ͤzu)fB\s`{A2vGhk\ln,j1ESMETlSrcq.rЬJKh^N%*֩JbINf GyT58f|<\c,[hv
TVgF"'Ch$I5rB׃I(D#`
OpSĞ8\mEʡtfG+<(9Ev>Hk};E(2[pc< 㸂2>`>*㄂xP?$cBa׉OT|R.FOQN)0"cT?OӍ)4b[ΊC笌( Y	i5tSBc{˦+jfS)݌ŸfT3HXoPJ	e	tBPn^&9Sמk4Ļ;]˗ִ?)	s׷ӆhRKE,H؜Gj7W0,	"6#efJK:|]3>2ME^	&|N{B
'ZZ&S-ɒ,K4w4L$̟TϳMfK]vp0I#WrCeїҬI/|s٬e$[i
JU4ndAkLX$γDZ>|;E]1IL&*}գ-s
^6)#ܩߒypV۝^S͛3A-wN	yl?p&+%Ϯ`ҵ֘@zHGM[뢰EKJg͸fzTS+UlBnc*^N]K:Ib:ǩ[W&32>!txnW%0obmɄ8sА!_Wd<Ȫ2&xo4Mo2[LӚ&!$k!BR\v̵0}?%\|^&#zX[?`@X1xaT/U
[!_{1Ã58u6B?KS?O*aQWM_*n\V]wg
W2]x\dzI&mb$*}񇷊*Kg2/_Čtt'b}#TBR5E\r㜒ʥ VJ;,eoI{f6;XM3(Ԕ|hcau[AZzWְnugnxQ,%~q
t[mN+m	+P stvuqnug֯e:̔(m*6Zf	{u`(ajﴕԤpzLɢ9A3bȶf(:5Թ$4C^laVkЗ ]fZ:Sd'v>ͼ'6.bj`_P-0w~-Q-̷M(9)2S({G9]6[<ŸKc('TEd8PE8*awqz*xCc2Ҙ#"ND=ע9;{$0D'wF]UqVDMPa+Zlq}wPbfG
&%%AMăF6jm7bX܉[*_hE1"r=9͡>c:g̿"V,?\Q,qS^^4#BvXe)B`)\41ev`)bUA]Nxn<%H<&[6}89\a	19(AQ,DE@"`U'i-t.w
uBzk9&MC.GS>
`/"%Dr?y\ˀ>¿8Ws%zQIC?So
0rdf6F$G2Q99j47HdD(,KdQ~vr%
;L͂|,d4[ɧ3,NR	dQ]ЍN7]TxMMC8[-j\lQKF'{RDWx(ٕbgdO|mֵ}_Cta(:Tep6^BmBʺJj;K*J\[]3)s0.Ac\y֊'5nF1axPc'Pۣ'UUXGuu"&[5=3+VK>Jx?%"ۙog>>qPF{43+DPc/bOF7fsP<_0:Q16g2KHuO;TԢ`^+P0jIM(Ut68+3S_qyM]?s#?3@DE:ZlK*OEO+:qHҨq̲&rt\eNw{E)1h/R`v3
[)MVz`習ir$j;d5LI3(}PK
h񑌏%4JKvH[9&)lg=f
d,M5fT[1.莄˞O/z=dvz	G;$gb$484
sw6r	IYN8"ՇN'`.~-8wq)	鰐vF[8df;'1NABgSe
	jS_%F	ͅ_.2H*
Yf4ͦI>b_K!(VI)>,tĠ9/q^~N׿'mq΄ƕ2lOMC/έLRztlqQpҔͫTo5s;;b&rn9/NmJs	zKI
?g v@8B\\XΦT*vVQ'D0
1HC%|vER҄NAvwBCg0*M4ţybk%
*}{,K(~b""Gu+˱a+Jc>o	'ðldTwS(=d|
-ϭԊ65Stdc.$ň4^!=v\;r"	y	`1_ů	/yh*tQ,8Q!r#yNnYZfS]+xǠouj)J\w<ŽnWEiK5P=zڞ=+E	
h-@T+‡HE(A_$sùbލjxaQ긆:~<
n긅l.lӰ!^;lUT:n9Ğ's] Mo.m)Ph9|wwdisۖe,l9a$Ih2k/Bڦ"F뱷YA$ؐ8o"|;87A@_~kK5,SI:5J&ӥ*%WKqz~rlc	R)^}v4WU=$iXZRy[&pzqÏ[8\|]74(}
?hbU-<4k5l[xᙁ6+J/b:ӵo(C)~YW`ڎ@zCu	L-rbe2Y]8;>LV[L2±#5mK1:YWSӋdGt:2{gK0u2TVVO+0JK+mN#-V({:E(%ɚD;.1Z-*C^C*h8uk&340!CR]}k e3&hk+W>|SZϓeU5LTՔN̝rB3PK
hktCŶm3s9!".I71/a Zs-՞BKH8,o!KP 3,fF^w
3ZU:Ƒrl8EtoG{b]62DG8Kwvz0_8R.S3&;!-÷D,_}!/+uBxNF*%
"
^
6yw9μJ'?}
ׄ3/
	^Ik1^$|oL1Ąa*Es1~KD^V21%)pu8UG΀B᧔BiF8hhDQ:P)v:Ã,ޏdNAx(!uQtLnDr@+׈mh1lR&%lR9SToEqO(Md4xF.h푙
8D'MPK
h<9!'	org/junit/runner/RunWith.classQKAkڥYYC=HlUDO
^	~}h·a0;<=l*JI~t
TH@^E*IZreB&O
dM!+Ժ N툮uUf{:=aDN9D;[}rd 8ң^ܴG|erL&^kanjjG/L]&;@m1|7i~4
Kȋ2wx+
S	Ua=+!aPK
h<ګJN<org/junit/runner/Runner.classuQN@}B("F/8UcbB0Qý+.Y~/x(lˁHۙ}f7S:aǁ]4mطb_)%C1X3TBapSQOG&_-,fA$&!ORr%pPs}gZDY/1'KU^{'#-D1Lrdv/j>(:qsG
0˖ҝzwaࢌ5l14֘`o˱wLxH5a]'cs,Bڅb2溟`tOu()p`TgBl!VΑ#OdIy;aPK
h"Μո?DYOFKXNְ88ӏ"o희ՄFA	ed@PK
h<,org/junit/runner/manipulation/Filter$2.classT[OA.lWAD*(rQD4#^~/xG6	ACXgh`޺q,)C,:(qU*3u)q
U3
'OBdV?ͱxGśZ
!zKsW׺PK
h<շ*-Z*org/junit/runner/manipulation/Filter.classSmOP~֭k7Njd6'AILa෮lwڥ/FB$FvL ~9=yyι|`/tXPDG
E(XRTG4,0T;ao6KۖoB~J!lߊnG]yC;لavQ`Ve.Π]?vIyPp@&͞2\Q UYa6npi0gF%V2|y3TBB7lwtl6'8-Y˲y	p.B6`(M
CJ>kieVJ(PMfmjLΎ`ʬq!/sORXg0^U;mTWH EmBm;}PK
hGGߵclGbbb0(2O+57%֔4U*ZX"?H	>*B?FMbTrN+'']NbQ3HD!^ֹbb;UHm^2l3Btokkv-䳌p9Q4sb; 5X97k[Y6cWlmkPK
h<$Ar,org/junit/runner/manipulation/Sortable.classA
0Dت x
k%7p.<8a=}l4X#J"sQlҒC0o={N6Mc{%e0'
a]?Sl¦swfH5PaUSWPK
h<",org/junit/runner/manipulation/Sorter$1.classRMo1}l6!R
(HԻRG;z?8 (؉jJԃ=yy?t1B܉p7½-ʞT3;GaOT]1
34:7ҝОȜe<U}mFɸ J&\iq+JXaZ.CɔR{vS#]0ðu=exGd\ñHmwE?=q0Vr-7,̒7ʭ6{˯O@&{{=vZs^4ӹTCaOqUDXa\&[Egꧽ0leuI4i4*-1V)K(
%b+Yuy#+ssN.(}>ż:gAeA]n_}#Z_ GW+Qy7}-!h@+sWPK
h<{g*org/junit/runner/manipulation/Sorter.class[SP'-MSnDҦPTV|@yq&ԈaBIG>8rMcR>={痯 b	ȸBS

9oʸ%cNAE^8gx|ñmk޼@ղS5:1Lѭ&k妙Y2iDKÝ#9%dF6eCy[؅f紊%hJ5k[Q$n
kibF0MJC-Mf]_-8h[ˎ9eKS;ڵtAunhDlSsCT"Yj5;b+Pp	㢄M['elv^N+qx)J[RusFU@GWNAI`onkIh渵mw&.^)O;"Te8/Q^X8u1Rdq/;W!\6em5]hs	88DN/(}h!Wn^
zJ4:ENC$RK$ՁXQ:"n%K5:ysAB>2d_0
:4;éc\N8&\|o`Z5,'8ܠ:}\	{$O %!T颃kPVÅw5*u;0yGq*)IL9ڟ	;AIfNKoS5d ,zf4G4Qk^oX/ywaМ3#]*l_xo։PK
h!Џ:6!쮴x93ݿ~zW]c٬1?%-0ِJ|M/BfLFk`^HvI(ԩRB*\FDǩjHc0LXa,N,V񟅉;V?6Pr	16f5N¤z%}iTcQq?snj	{w-MNü;0&m}mhWT$Iu$Mo\uO^A$cfGDtcPo
@_{%څdѭk_Z
J*7	x2Y"X.y1A$ESNc&l{,gW1wedEV@V
';JF_vss7kPK
h`0㾠@^P$0"!x"zZ<]M4lڤp(T3L3AaZ<yREdsJˎ
8jJdoaAl8ga\:i`xZ޺tA?\jWvivLľH3B{O2gX^?o/(S
=YpHjphJ.w殟z:&<9b>hF :1|N>湟PcJe]3[N&nᔸۅ-%,I&a3&OPK
h<1org/junit/runner/notification/RunNotifier$2.classS[OA]vYiEATԪt_0&ӰCY?D42-76fΜsom}@UL&+*g>hx`8
NTċRDdGd 
ٓ>OdTg3IvW'41vC#Oߜ舟>y$3o:جa
wY6c*h0s̃fO$~,ߥ2
(GY(S7Pedp~Tϕ*ws]*$'qgжB<a@9/ycQS`P$,A5R9{_(sLRAezKu,`t,sk>ǜڲApRèg`BL.Yc6l:~60<*}qP/
pU:;ڗIMyopp:N>01<	2n^{P3ӀV$mJ?0k;'`	*þ1w&`˳h`ZY]Qʧ!5ghTf
Q:%]
J8N\b}rm,aEڙBdUOPK
hފMl3,f_2N93
[@{Fii䋎SI.%)?coE2{&vl4ب²a↍vMh(Ë'/U_qUg\
24G'}S'h;0"Ç8YwgcN-1GGؠK_@^Rl7;@^`q+@kfHk.	 D˨c-ܦu
wF!_ՇT]JaLBYFí冣p{p>dxigS!37PK
h<1org/junit/runner/notification/RunNotifier$5.classT[O@f)ۭ 
u-/B 1Yyŧ;;,?xf
,Ƈ&9gܦ~	*X-6L<,4,ܑi&*\`Pnާ@|T5ҏ<	ľTo:CNeً0Ne'Aܵ	A԰aaA.3A^GR*Z?Q߿NYa'q,l'MsMDtqԛh붏Oj4S?	[;AXIJ
NWjp2&iSswn\z;h&A!fiu<:h7pRD;+~Er Y*$JZ]"^֔(}!a:Fd}aTPK
h<1org/junit/runner/notification/RunNotifier$6.classS[OA]vv E.t/TӰCY/2M|gBmn39gQihĒXP0uzG$A,_2R(ǙgJ:b0ӾLޯ*JeW\/2"a$9>fhw0Cc;*-^diGy,>4<]n;I"Ȳ^T}ʱw"GXx0{m$,P~(Lj@6	 zEڏ:V4:v`ኃ*,;h¥hfq}g
u:!W=٩ЮŁHݞbaX._>%nL5AHۤ^L4`mUC*I[(L)v/(]'6w"4j%~ADpc	q}Hs?(o'<tsa:--J8J\|}wr],`yڙ3(?PK
h<91org/junit/runner/notification/RunNotifier$7.classSn@6qm6m@Bn"$TZ	@^8mMY#T&H$<ӆDۙofv}@5L&+6Lڸ;2̞iיr'=8W2\)O[f֗icSřʐkWE
]$:$qbqEapUňQX0oID%L837خc-9Ysl2b¯kAqql,lf3n*NY-pR57Ð-zq:QQS ĉ2[*E@Y"Cj)f:"H˟ȟ/n`?o8-Qz|sngoEyi[*Sݔ0C*_sK^ۂxj RG3hDT븆*:nঊ	dumN24U8zwp-X򸊻:rt:pJ/ԢUoYH
Ve%..;}jή=Ը}A,_
dާJf2vĝ'S*CrD	_~,816r}8M0mϷ́"V`ܢM~s0g{< _䆖䮴|'IADupiHW31V]!-Vcdt`5!h#|G
"od;0L~I*gzY(2}%vw
׿%֖)ʧDюn$i{
Y&F%P恓4".=t	zN#Mz=)i'IGJQ4̄	SX@DQD)I!{D0JQAXLa1B$c[D4q$=D)=PK
h<</org/junit/runner/notification/RunNotifier.classWEǿ6JCDA	m)BQ~J%@ǒLⲋ⓯>C}w=s?a	!s2?wf3_ੂA<aE*kah>	aCA>V)smKB]U]
M
zĤGL2
Zpbҏ-'B.4HJeѲhdܚU6MjIDhrW=PyGB<Вr-tҴrݼ9	+/	CIfQO+}s)g`ig#y3C~ڒ{ZUut$ʹ&0hh(1L1( "l=:zW,g뎬fUn;rT*,p;mi)CgJ0tYݶwXG+څjtLE0ͥc2vՔ!EuZ1]v~O">мhri	Iԋe,?)e;3St8UC%DIy+521[xα,HPB؍+1^aRz-/_G`	W
vt癹5[^4NC".!
iO6}OLanyjOwyV3YdzR̛NGFz2
.ETWJb!7mYS#:C}Iՠeګ.˺l:=
!*r6B?hʟ1-ӳjc'o#^/MZ'@NjhM/!Cm`e/Oh!xva$T]Lޅ*" ǻ.!Ghe#>zp%>Δ![=d+ÔDNydD"[R\ 3x_"?(}"c)	ڥ:+Oj!z-axSsq6a2tW.Ce.X!2!{$kH5_D^/ V8!%FU"'5K^M`?PK
h<͜5w:org/junit/runner/notification/StoppedByUserException.class1OAAN-ܘb!rrؽYV&q0VVnv7zp7)e)ik&!tFd^$W5hFG`dg
Qrܽ&C3V23:#Cb3H儱^?XzBMS5;pϱJJc$hE8O @DˍK]Tx}
w
+;赌YD
`+SPK
hC1:~{"K
5TUuɩDOfPCqBT	RTPK
hB7UK"e%{fό,JX	1!q3n(3VA<kb;Z,~Lr=Aųl'ۤz)	|1P}0ߕZlӾ=W,vM%7>DMx[kn)4:ʰ@ACJ1Xq=#:lC]3ؔ>yT׆Nɤnh܍pe*jgxqJ	:QO-fҼjN?MiaKcӦ82`Ҋv]ǝHvTņ0VipghYH^VdCz$l=—3G{~zh|ȏOK]U"d%Ԏc='ij*`Q|.RHs.+9*2c>FPK
h<9,.org/junit/runners/BlockJUnit4ClassRunner.classY	xǕ~OV@H`{0X$a#!"GFj1QD8vĐMMfc;$Dv]dwv7{f===`O]Uջ[?"Zgu:k:?#':)t\/4Ky4-sF2?O|a2o4!J_wF~"Й˸Hbi\\&2L25d6_YU\-Mtken:7pZ"6pS7s|YRIzܠ/!/&z8 Mm:vRiVI)jih|N|tjN괟ow	o0oxNwf
Z[en۠p^ACyޡ.ثqw2n"VbS}`xD3vn񍭃Lz1f@p8P0<Yw}1+Զ;Org,xp4t *FeZß1dQ}Mm[0_92'V4x7S~k4L$cX0G@Y#21+tx?02|;gc
CMHa|7cokp
zGJKCMGc<%ShO&VViyhM4)Tns@3]Oߍb-;oKXP(̪T~@?>ɰJ 4m~?l#(eONL-NQf\>nDam]fwZaYvȠ/
f"WA0)]VO]켰vX;BANǩpFX+aw[]zI߲)΂yC?(=ƴsp{;ey?%<zilQP3C?0:I'`Z3.:ӫXY1Uߣ]~KZ7qhH7LiEЩ#{0Z6iQ o	!\iܫCjlon
]ź6#[WUel-)`_W^05ffM]Z,s=..
\HyU3aU`- -DƥҌMH=Sy'L;S.>{$Vg
aDn0rcOT^Z#rK\wc[MĽ]J]rYSc6wǮ`_@׹XW᩻s|1)-p,E'_#|3mf
E{PWm5J*8u/++"MIHC뇎|'9e1i[rsH8}2S=SL
6X Rx|'ybaZŃg};t*TR#
(qb
7@EOT>C|o4VW]TB)F{EiRQ)wPx7GxK݇	:":J)S־rx|SE[v^Tk'Iz
UMEw}
Ek?FO_9MZ[4MS9ҿcӤ:UvKՋB=T Y
@zvPztQ=R

b]XwCO] t+Rz=@B!AW	]%W?L8oSRWla;h"0(UCj*Q}4LQd-.QrrCޥZ@q|ˊPm&c*2fy%OS!qfyHU:CO:; HdlYcISPih.-v+v}pyo63.!@]"uiUjۇa
]EvϺN'4fsP{ÞY]^P{'egIS
uҜ9s.,rنl_9d7]
sP9ZD1",,Hnۿ1y|WB=1;YVG+/h.S;{6FӋ%ZHh][eYu^#ZGSSb̑	wsvBj(W]N=+/j5
_oì=ƏJ3pKnH___TWW _UO98>uڼu֟+Eahn횦	hi`~η;kIvTE~x1
mW"PRӧ鼒f\Wo\WKg}8XiTFƿ}~cSѤ㎿Lu8}_mӴ=;~cTUGd#HD}!fgb4ݱȄ3#OAK=d+]6ٚ(sQ!5:`?z1"#P&%GÒ
\QŦf5.rhߡU(pP#PK
h1M't?R{18\˄m'#▲CiߦOcxޘ<&a0Tb8ڣdLDޙPլ#AC_|UVOONy~^s3WO%}K~E
FL^P:FʚkaP
RTE	1;5h*Ix/EPK
h<4T0org/junit/runners/Parameterized$Parameters.classJ1kתAD=x0x$bRW/:lVB}4>%^ZBIf'/`W |
7;mHWNz8^tͼ:CHX laJ6U`hό͸ ?soB<~̙s9=i/ g0HiV^]|R*ǵXG:>ֱ(!!7
§>%&(
p(I+Xq`qV\x8[)/q'9'sֺþS"8CxzUZ^)_Zvw"`^xN"H]:wO:t<0nڵ 7;MĶ/x&m]#kJMe8:σP\ͬTsNSQ=4susEp`(a8̜ޭl500.ޱZ^e8S9UJ
[p+2(mo/UB
%G;xt s&^V,z+Jĥ8ߩqnzFfrp_t4)C=ۡZ\gr2M9E}֎ًp!|E#o3"
YT5BVC;AՑ)6\{6Ҟ:EǶdrԐꙋB=YW3=q"V+3&l^4qGMxuěxKG`"DEǺ
ܡ4wlO)ziA;Ar4^a\pt^܊OKV	qKk3D:6M:񕉯[঎L@*L&~%H>|TgޣHw*uTu]U‹Wص&j&e};wPFDA4PM/xQV%!Ǟ
`,=[Mm8<Zo2tCײ/RI˶y@_	6{gYY#{6yuKR}Q(KFvûY/%ٮ:-
ל~eUg8^[os8):Lº{\:ʑ܅x\G$;L3Pj!X#tN=DwjH{eyPtb)h
8Ev4N&V&UCzdV|IY3гH-D+QY(=1lVn=D_øb@]쮺+,ja10Px#Kyxo&#CQgqNژirגP=
5ԪcIYplTmɖHP51]IN^W;t]\pI綻PZA[UoNԩK{nH^fp¹F/Ϸy.+ԥ9QtPK
h<\h
%org/junit/runners/Parameterized.classW[Wlp((j`
RbRX%YBMw7ڛ͊Z{ڠkC/j&\گ9svfofΙs?`"i
pLNj=ˇJP Bƨ!	c"\rL ʇIE&,qS"jp'9g씈j𒀗jʦy$iѣ!O*bR/gr>2WЬ28.OɁF!Ujc(T4ي
Ck>njkF[-$`96530Y^T5?>9Ch8eA=$GeCI&SKJs\tt)%L
'/o{Ut*x$L_c&Rmޒe"ãJȲ#vO)59xJ+FÆQ^| [rLdžӗ'Th ޼erWO"ze.NƄco}'Tx9a7Ԇ.C%ܴBDgp^Ae7{Gɡb
zdd9[ӭ|A@RzTg8Ѓ^Ih*iEg%(K؏.	C25ܯ%
xC›xۿ(mC'?{IxQȬ9~$K>>1>p2l[aV%\ႀ>
	F*a6t'.Uơz],>UCu%[D_t.sV'|)+|->4[˄Ns5㪥dIV.dKF)P&c֌܋#	.Q0p$
\]9D q.ZVra1j6O(ӱnSJtaw<ʹ1tNMi(Toڜνd3NZr#ٯL[v((fTB,&_b('6
ڥdNZDhm!%mk?PK
hUnMf
.w.*O֮&eeOYl.vD8qu?

/&ƥe3\u<8/ynB{Κi|GY`t	O
vV@&?-s\VR1T2ViK;-ܥqlv#PK
h<*L&org/junit/runners/ParentRunner$2.classS[OA=ӭ-,b	6vY&,?evdS/i?j	WaSWa..gp9H*q1Zgg(}"
9j\e]C7ƐppLN{ʿU|CYN(ˑ[۸Xx`PK
h<9*&org/junit/runners/ParentRunner$3.classSmkA~wjԗj5jzis-E
B~vsY
K%$
~cTqZcAfna晝㓯#VaRˎS彣5Ȱi6-WýIK𪪒=ScHۤ[0RiL(EBX8z>GoyoCJ:r̵/n^WöX
̣bPG<xDg>2d'ʰ<-Sɨ/YZ14UܶEjn`
+GCVø"}t)'>i5R\DR`O&#x@&XɨN;ZYR3XiAS+<5c:1)H+}c"yKA'nAqnArgneަ4N5܉ewIR<]J1~PK
h<&s
#$org/junit/runners/ParentRunner.classX	x\Uo2yyYKڴM.LI$
iM(2yI^;	3.QwQT%"m-%JQ)+B=7o,$˻w9Y9_n+E[8>w|OH?旟**9U	~
~b&
#zTc*qT1?X?'<)_?fgx<//hxw?W5~VT)E8E@*	M߄³bUx~Q
|*LŹx@动PET߁>=
ؠhHc!=7u(pB	,Dp aD#~s$ƦDb``!=4f	moV"tw,݁8v6@y{Fw鱾0TvG@wkѕ22u9lH@r=!gdIHRĒ<;:"ՙL;nGx$kF񝝥?	JĆ!#"!wcq4aF<ęI!=tA`SvDG%IL[]ŴjI9'lH4aA3z=ZdӤ$kqܶ)Ucn}6L:EqHH3{3yOE.KBmtWhWlpʒ쳰32=nRNv6hl (lQ$8"dhi=yP@0:+b}=ȲTQ3ee*b3
8 ]lkNN
P4'%bM9%xd)j>#1^ti+v^F٤SD%YaA]Cw_iRזV$+dN[1-sUe
)o0J=<\Xz1#2H4(K'VYNˈ̑ HEA3+*9RűՈM#+{wQz.-D|F&##zhzI83 {q5tm#~V/Ҕ㹚8uS VSLdFRE3yTV(+߮Z/p2tbVk=Y=*3sfVFV_nLavO|(:m I3I3Ztx$ ӻna,SrVyTxT
zY3~N1;j"F|͟A76]'P;YL^tb(Bڇ??wB![5unftO玓݄շ7uC,)XGe[>`tN[#Qٮs4YP!l
o,뚲~SY2H@T2QwaG^nPɝ@ȑ9RB\C
	
q]Go4.GW{EG!pӢr4C=ZA!@Py1YZPUE؀~:7j.M&e-@sKB\\h|w*Aﻱ~5/{,%U(u&rRFS^eCB#iЫlr@DR?gxxڼPAbgj\'P)^TStUףg`f]f~M^`B9:/‡YExnOѬ4}!.g>v,5[TJ?ϥf[V'h%kq?3On%+|ľe8
ILj!<Wڠ[	6Z-
oQ yHGEȑ ܶD7DM3Aq4
s1]8InṄ7@:2:y8BC(E(,QPL	/8Yoe6,y6dzq1N?3NlC'W$i
JUK5LxlZsq6|/Ht|~-RhMw۶]:)eK,{(r'
{003ER4;!KdtG
&
$ySFg&BP.+lY+lTȧpK&J8>)6SvUx[z*>ZKtKV:$iTsM78!ɪIsqܙ\g:u]rb܅q{{qSΛ6orb%>wS7eS&Y$M6[r6jPػ[hx9PK
hM8;{'KF!ڲp BZ'0r45q?sYYTzid#YRȱ<UV9X|zExo^hP6wAB챕A.PK
h<t,W)${Xbˈ?:eHυCC77"NdymC_
yAF/%A^$nBR/\rZ&%?el|iG4".ډx-8L*`⢢~޽(8qLxA8L~Bq ;OK6=A2  ͸xhQѷzM1,˱ڗ"a_Lah?8H{eoStL&9$eZ@BڗCI_/J̈3q(	|.1#d]`pM1Mд7L}N	Mż[ƖllIrɾM򬗮3jF,}jq1H8pM¸Dr]B炷Л'sKVr?UUӔeyGՄK&pQBƅͽBNʸE<"-[!pU)7ꧽ-0@^xL
~RPK
hv
*$%:CY
zoPK
h<
;/org/junit/runners/model/FrameworkMethod$1.classSmoP~. X
sm
[%F]bȖF%Kwe܂s~?~(Y+SAKx6ȣPdHka}nJ4w#D{3d>̓ăv
5kcsf=< {qz'oDrK`{[O!V!{Tv^!:oHJt-.g0g^U+ Iqreթ3Ktu|
%
[dAK
!/&a|t{%lTv*ĶK4b
u\U	$u\#G:vXOQ,\k;.-k.o6N:RGctUJe	ߟdƐzsOa6,oSU=y~5Ѽ.l?-0/\M4;)scKS7Ҏm1U;JEkjVe_a44K5+V͚TV؊b,a<4ó,hXDIiLw#)L}!Gq#(Y;7L^.vyW1UD0%d,!IHOV\0
1ڐwم
Q([6sKH$_H68\SWtfv$'m8&VVWX͕Mgq(A2G-;WIHdWdE[|R3g/_	Q<	Ljʑpw`St	6Kn	y
>K8j		J=DfCëֱ)(iO3 Q~'h1uc;UAa'qT}t'e
c>?\GCQ_Gn]C)}\|ԱegE#kAɱ,Z| <ۧ$tf\쟿?~XcJI$QN2Q]TVƽ5}`HW=4y/q>Ɛx_ғ>!]aɆqyJ2=v=}䭞"N0W,7bUe+^-!w!W9:cCͭ=ٱ!2t]gO&	v>k11T?Izxؚl4ABifPCt܎>+Sq|GU$J)O9Oᅲ-9Jwa29O!,Tޥ)OmqThY-3\Cf=VDJ~H
+q1Z]Ѧ49ܠ?U8)id_v1::ϓ
MfU!rDVyZ/$elpEJ&S蜢}ɍ]hU՞#Y+h>G:7]%CՎeGX)!k:TYi'J>MR.R{KcewSSXlmq+"_FTv5@m|H3P[$}ZPK
h<[+org/junit/runners/model/RunnerBuilder.classVM[U~'L2tVB &- -A0ag&U\wMy<;B}E9ɟUhT&-L|V0
wp3
JU9̫*Tx<G
ƤxRhKP6uװ}O±u/~Q‘j~5$ןn[dGIJhI;ˆ6mcdEIS֭95{$5LS_(VlpqL6V1eåxq3"ګ7)ش7؊^g+
I ͮ">QHYLw3jӗ,FH?{HMi<5|u7jǟlM
%tݔ鉦l-70
0*:rhnxvz^U׸2l.҄Wm[f3kdWKN-fp.Ћ}[okC&ׅr߯ikVup]ǝ167Эpa46E&(2uV7?@p,Ot*xdmL{tom
ʎL3TbFtGqgiV
V4bMaOAK
ypkez2"9o4
%4ިcHãuӜӚUP}x
12#,G.gq7t:iXln((?o?E_\O-wєD+.%h8݁Ela-?C~h^dq;-{8Ȓh\jLI">/_kG6ۻPr;h4KPAk@e2D
t΃]ji>a4*DOsH?.ԅ6wh-wwpUn(1ԉJ%?,TDPˍ'=WE098pƫVBK]GQ$εWԡc>tN}vA6=+*%E.$6
x:jmX%A쮰ZH7JHxViԌao\f_&o禇^^[.œ#%
lON=..=fE=!=?b+ThV[g9z~@>kNG\c5nb  ~8aus/PK
h<?
'org/junit/runners/model/TestClass.classW~:V76v,AH6.1↜nljBB)l䵭 KjW --%4MKm)Pچ؄=3,)_;;;{<;̾Gd|؏JGDQ?c>Ç|:|ͣ2>))?yBƤ|Ə'TY1}^hhN|QƗX#Yќ1%cZxSb~32^O	/	'2">|͏N<,2^ِRY	}սjGJMvC%%GӪ5	ͥݑ5i׌p'K3j$3iksF2ѯNP֙#ݕ%Fw_F؝K'=Nkzc<3:ztu\ۗo̯^ZxIjrgn6mٖIJ!N2 odZȍ+őLBMmS"ZPFRZ谣^UחH
4^	5Ivjz{	
h."z
MW.cI.>/q-kse& &)CVM۬3Qp5#rX͌4-A7%

$,,rLu(8DE7U!䵌IX^\ꄄeD/j2u.%.a

;6{UK7)6{T3aXvey:
0م\5OxPEhj}DBAnғ߁îbg&ȌWdf	.1'@hrn.k'Ces)aslj]d`	tE=+k:u`OmC%x]g握"WIB+_Dxl[bb]8Sӷpn)'EE6%Z6iB}nQR"7^Y^Z~tpa͞o29=$-޹\%ūVnVc*ѭ`h*kDh}47΍@MPB%t(Ê{5PQ%+bT7-V|W}RHI
~JXVQ#H6lWcD/T܃{w(Ha\/K_ע9+7
~$
w?D}ffx*8^蚂?	Eq;?e:J)wo\Z]x6ᕸ 2Kqh͙}p:CߧtH
>\j8HpҍZXwAa-=/._ΗE4^zo*%mNc&;,!~-]Uv>Hi4<ͭҚKօP\qAIf>mxqRRto9F|ef\$ԑ35^єk"gMʹ4Rr\đtPx%q'&aluTfg޲JY]\h
	oW
b|H)
k$q4i옆$܅'=	oD q?YT;
ȳN	m0K1e^Khhe1w}cXt16wi4Q{zsgK.8K&zcنXp9Z	,B؎e<&8}	D1K
vc7ofj54\rm#Oæ:r9r1L
-ސ8-cbNʇ琝0%j93~<cmx:cޠ.ϩich7cp?#WCC犞\&}Σ=vk~bѼdZ*r8-ոs2ÜbR&zPlpyDT>;vBDV1P޲:v,0-4`B6]fQs‰khFbI91dK1Ĉ(V<_2a[XjY_hn),taXT2_\_o!%n8~,1̞eSܰ3:8zcv+B5:Kpqbo){ 'v=]ȍE:bO	"b'(n(G_Acev6sl+`J`5X;~V[=nvQ|7>^ZS~B*Hw޶>quDd'L,MG=#;9ƻfZJz_i	ћBJn.e47ٚ%RHlK珞9DjE潻(m>]xwQ89</v =v V >hCi/
r/u*
	ks>#mSVyȢ17X8|;VL'Ͻt(ܵ$	~<#=L?$5=7뙂4,~&<'ǔW o6hCYu]T&gpvQB0=h>oPK
h<	AMETA-INF/PK
h<S_+META-INF/MANIFEST.MFPK
h<Ajunit/PK
h<Ajunit/extensions/PK
h<Ajunit/framework/PK
h<
A1junit/runner/PK
h<
A\junit/textui/PK
yp6Aorg/PK
h<
Aorg/hamcrest/PK
h<Aorg/hamcrest/core/PK
h<Aorg/hamcrest/internal/PK
h<
A8org/junit/PK
h<A`org/junit/experimental/PK
h<"Aorg/junit/experimental/categories/PK
h<Aorg/junit/experimental/max/PK
h<Aorg/junit/experimental/results/PK
h<AKorg/junit/experimental/runners/PK
h< Aorg/junit/experimental/theories/PK
h<)Aorg/junit/experimental/theories/internal/PK
h<*A
org/junit/experimental/theories/suppliers/PK
h<AUorg/junit/internal/PK
h<Aorg/junit/internal/builders/PK
h<Aorg/junit/internal/matchers/PK
h<Aorg/junit/internal/requests/PK
h<A4org/junit/internal/runners/PK
h<!Amorg/junit/internal/runners/model/PK
h<&Aorg/junit/internal/runners/statements/PK
h<Aorg/junit/matchers/PK
h<A!org/junit/rules/PK
h<AOorg/junit/runner/PK
h<A~org/junit/runner/manipulation/PK
h<Aorg/junit/runner/notification/PK
h<Aorg/junit/runners/PK
h<A&org/junit/runners/model/PK
yp6s!!\LICENSE.txtPK
h<P(
junit/extensions/ActiveTestSuite$1.classPK
h<`ǫ&junit/extensions/ActiveTestSuite.classPK
h<d<#junit/extensions/RepeatedTest.classPK
hV9f@junit/framework/Test.classPK
h<<99
3Ajunit/framework/TestCase.classPK
h<0q2Q8!Gjunit/framework/TestFailure.classPK
hV!porg/junit/ComparisonFailure.classPK
h<org/junit/Ignore.classPK
horg/junit/Test$None.classPK
hGe:!org/junit/experimental/max/MaxHistory$TestComparator.classPK
h<+%org/junit/experimental/max/MaxHistory.classPK
h<@@0,org/junit/experimental/results/FailureList.classPK
h<{|40org/junit/experimental/results/PrintableResult.classPK
h-?org/junit/experimental/runners/Enclosed.classPK
h<4J7/Aorg/junit/experimental/theories/DataPoint.classPK
hV,rorg/junit/experimental/theories/internal/AllMembersSupplier$MethodParameterValue.classPK
h<ڇZA"vorg/junit/experimental/theories/internal/AllMembersSupplier.classPK
h d(org/junit/internal/matchers/Each$1.classPK
h<;*&org/junit/internal/matchers/Each.classPK
h4org/junit/internal/runners/TestMethod.classPK
h78org/junit/internal/runners/model/EachTestNotifier.classPK
horg/junit/runners/BlockJUnit4ClassRunner.classPK
h java.trace
atd-2.1.0/atdj/test/test.atd000066400000000000000000000016741357165332000156510ustar00rootroot00000000000000(* Sum (enum) *)
type e = [ Alpha | Beta ]

(* Sum *)
type sample_sum = [
  | Simple_tag
  | Bool of bool
  | Int of int
  | Float of float
  | String  of string
  | Simple_record of simple_record
  | Complex_record of complex_record
  | Record_with_defaults of record_with_defaults
]

(* Record *)
type complex_record = {
  b  : bool;
  i : int;
  s : string;
  l : bool list;
  sample_sum : sample_sum;

  (* Java keywords used as field names *)
  ?class : int option;
  ?final  : int option;

  (* List of records *)
  l2 : record_with_defaults list;
}



(* Record with default fields *)
type record_with_defaults = {
  ~b : bool;
  ~i : int;
  ~s : string;
  ~o : bool option;
  ~l : bool list;
  ~e : e;
}

(* Record with optional field *)
type simple_record = { ?o : bool option }

(* https://github.com/esperco/atdj/issues/2 *)
type a = [ A of b list ]
type b = [ B ]
atd-2.1.0/atds.opam000066400000000000000000000022761357165332000141070ustar00rootroot00000000000000# This file is generated by dune, edit dune-project instead
opam-version: "2.0"
synopsis: "ATD Code generator for Scala"
description: "ATD Code generator for Scala"
maintainer: ["Rudi Grinberg "]
authors: [
  "Martin Jambon "
  "David Sheets "
  "Rudi Grinberg "
  "Ivan Jager "
  "Jeff Meister "
  "Carmelo Piccione "
  "Raman Varabets "
  "Mathieu Baudet "
  "Rauan Mayemir "
  "Louis Roché "
  "Brendan Long "
  "Christophe Troestler "
  "Vincent Bernardoff "
  "haoyang "
]
license: "MIT"
homepage: "https://github.com/ahrefs/atd"
bug-reports: "https://github.com/ahrefs/atd/issues"
depends: [
  "ocaml" {>= "4.02"}
  "dune" {>= "1.11"}
  "atd" {>= "2.0.0"}
  "re"
]
build: [
  ["dune" "subst"] {pinned}
  [
    "dune"
    "build"
    "-p"
    name
    "-j"
    jobs
    "@install"
    "@runtest" {with-test}
    "@doc" {with-doc}
  ]
]
dev-repo: "git+https://github.com/ahrefs/atd.git"
atd-2.1.0/atds/000077500000000000000000000000001357165332000132225ustar00rootroot00000000000000atd-2.1.0/atds/AUTHORS000066400000000000000000000002331357165332000142700ustar00rootroot00000000000000Ivan Jager 
John Billings 
Martin Jambon 
and contributors that can be found in the git history.
atd-2.1.0/atds/README.md000066400000000000000000000014251357165332000145030ustar00rootroot00000000000000Atds
====

Atds is a program that generates a Scala interface from type definitions.
In particular, given a set of ATD type definitions,
this tool generates a set of Scala case classes representing those types
with built-in JSON serializers. (Deserializers planned.)

The primary benefits of using the generated interface, over using a 
JSON library and writing case classes directly, are safety and ease of use
when the same interface is needed in other languages.

Don't repeat yourself when defining a JSON interface in multiple languages. 
Instead generate compatible interfaces for all languages from a single definition.

Even if you're only using Scala, you may find the ATD definitions more concise
and less boilerplaity than the equivalent Scala types. (Especially for sum types)
atd-2.1.0/atds/TODO000066400000000000000000000004651357165332000137170ustar00rootroot00000000000000- produce an output tree using Atd.Indent rather fprintf
  (for clarity and atdj performance)
- translate atd syntax tree first, then generate code instead of doing
  everything in the same pass (for clarity and atdj performance)
- merge into atdgen
- add location information to exceptions (need own parser)
atd-2.1.0/atds/src/000077500000000000000000000000001357165332000140115ustar00rootroot00000000000000atd-2.1.0/atds/src/atds_env.ml000066400000000000000000000005271357165332000161520ustar00rootroot00000000000000(* Translation environment *)

type id = string
type ty_name = string

type env_t = {
  module_items : (string * Atd.Ast.type_expr) list;
  package      : string;
  input_file   : string option;
  output       : out_channel;
}

let default_env = {
  module_items = [];
  package      = "out";
  input_file   = None;
  output       = stdout;
}
atd-2.1.0/atds/src/atds_helper.ml000066400000000000000000000015311357165332000166350ustar00rootroot00000000000000(* Helper classes *)

open Atd.Import
open Atds_env

(* TODO: Extract to to a plain file? *)

let output_atds env =
  fprintf env.output "\
/**
 * Common utility interface.
 */
trait Atds {

  /**
   * Get the Argonaut JSON representation.
   * Please use the argonaut encoder rather than calling this directly.
   */
  protected def toArgonaut: argonaut.Json

  // These may be optimized later, and the dependency on Argonaut could be removed.

  /**
   * Get the JSON string representation.
   * @return The JSON string.
   */
  def toJson: String = toArgonaut.nospaces

  /**
   * Write the JSON representation to a buffer.
   */
  def toJsonBuffer(out: java.lang.StringBuilder): Unit = out.append(toJson)

}

object Atds {

  implicit def argonautCodecAtds[A <: Atds] = new argonaut.EncodeJson[A] {
    override def encode(a: A) = a.toArgonaut
  }

}
"
atd-2.1.0/atds/src/atds_main.ml000066400000000000000000000037261357165332000163120ustar00rootroot00000000000000(* Main *)

open Atd.Import
open Atds_env

let args_spec env = Arg.align
    [ "-package",
      Arg.String (fun x -> env := { !env with package = x }),
      " Package name of generated files";
      "-o",
      Arg.String (fun x -> env := { !env with output = open_out x }),
      " File name for Scala output"
    ]

let usage_msg = "Usage: " ^ Sys.argv.(0) ^ "  \nOptions are:"

let main () =
  Printexc.record_backtrace true;
  let env = ref default_env in

  (* Parse command line options *)
  let args_spec' = args_spec env in
  Arg.parse args_spec'
    (fun x -> env := { !env with input_file = Some x }) usage_msg;
  let env = !env in

  (* Check for input file *)
  let input_file =
    match env.input_file with
      | None   ->
          prerr_endline "No input file specified";
          Arg.usage args_spec' usage_msg;
          exit 1
      | Some x ->
          if not (Filename.check_suffix x ".atd") then (
            prerr_endline "Input filename must end with `.atd'";
            Arg.usage args_spec' usage_msg;
            exit 1
          ) else x in

  (* Validate package name *)
  let re = Str.regexp "^[a-zA-Z0-9]+\\(\\.[a-zA-Z0-9]+\\)*$" in
  if not (Str.string_match re env.package 0) then (
    prerr_endline "Invalid package name";
    Arg.usage args_spec' usage_msg;
    exit 1
  );

  (* Parse ATD file *)
  let (atd_head, atd_module), _original_types =
    Atd.Util.load_file
      ~expand:false ~inherit_fields:true ~inherit_variants:true input_file
  in
  let env = {
    env with
    module_items =
      List.map
        (function (Atd.Ast.Type (_, (name, _, _), atd_ty)) -> (name, atd_ty))
        atd_module
  } in

  let close_package = Atds_trans.open_package env in

  (* Output helper classes *)
  Atds_helper.output_atds env;

  (* Generate classes from ATD definition *)
  let _ = Atds_trans.trans_module env atd_module in

  close_package()

let () =
  try main ()
  with Atd.Ast.Atd_error s as e ->
    eprintf "Error:\n%s\n" s;
    raise e
atd-2.1.0/atds/src/atds_names.ml000066400000000000000000000067561357165332000164770ustar00rootroot00000000000000open Atd.Import
(* Names *)

let to_camel_case (s : string) =
  let res    = Bytes.of_string s in
  let offset = ref 0 in
  let upper  = ref true in
  let f = function
    | '_' ->
        upper := true;
    | ('0'|'1'|'2'|'3'|'4'|'5'|'6'|'7'|'8'|'9') as x ->
        upper := true;
        Bytes.set res !offset x;
        incr offset
    | _ as x ->
        if !upper then (
          Bytes.set res !offset (Char.uppercase_ascii x);
          upper := false
        ) else
          Bytes.set res !offset x;
        incr offset in
  String.iter f s;
  Bytes.to_string (Bytes.sub res 0 !offset)

(* Translate type names into idiomatic Scala names.  We special case
 * `string', `int', `bool' and `float` (see code).  For the remainder, we remove
 * underscores and capitalise any character that is immediately following
 * an underscore or digit.  We also capitalise the initial character
 * e.g. "foo_bar42baz" becomes "FooBar42Baz". *)
let to_class_name str =
  match str with
    | "string" -> "String"
    | "int"    -> "Int"
    | "bool"   -> "Boolean"
    | "float"  -> "Double"
    | _ -> to_camel_case str

(* Per https://scala-lang.org/files/archive/spec/2.12/01-lexical-syntax.html *)
let scala_keywords = [
  "abstract";
  "case";
  "catch";
  "class";
  "def";
  "do";
  "else";
  "extends";
  "false";
  "final";
  "finally";
  "for";
  "forSome";
  "if";
  "implicit";
  "import";
  "lazy";
  "macro";
  "match";
  "new";
  "null";
  "object";
  "override";
  "package";
  "private";
  "protected";
  "return";
  "sealed";
  "super";
  "this";
  "throw";
  "trait";
  "try";
  "true";
  "type";
  "val";
  "var";
  "while";
  "with";
  "yield";
]

let is_scala_keyword =
  let tbl = Hashtbl.create 200 in
  List.iter (fun k -> Hashtbl.add tbl k ()) scala_keywords;
  fun k -> Hashtbl.mem tbl k

(*
   Automatically append an underscore to a field name if it is a Scala keyword.
   Use the alternative provided as  if available.

   ATD field                           Scala name

   not_a_keyword                       not_a_keyword
   class                               class_
   class      class_name
   not_a_keyword   class

*)
let get_scala_field_name field_name annot =
  let field_name =
    if is_scala_keyword field_name then
      field_name ^ "_"
    else
      field_name
  in
  Atd.Annot.get_field
    ~parse:(fun s -> Some s)
    ~default:field_name
    ~sections:["scala"]
    ~field:"name"
    annot

let get_scala_variant_name field_name annot =
  let lower_field_name = String.lowercase_ascii field_name in
  let field_name =
    if is_scala_keyword lower_field_name then
      field_name ^ "_"
    else
      field_name
  in
  let field_name =
    Atd.Annot.get_field
      ~parse:(fun s -> Some s)
      ~default:field_name
      ~sections:["scala"]
      ~field:"name"
      annot
  in
  to_camel_case field_name


let get_json_field_name field_name annot =
  Atd.Annot.get_field
    ~parse:(fun s -> Some s)
    ~default:field_name
    ~sections:["json"]
    ~field:"name"
    annot

let get_json_variant_name field_name annot =
  Atd.Annot.get_field
    ~parse:(fun s -> Some s)
    ~default:field_name
    ~sections:["json"]
    ~field:"name"
    annot

(* Splits a package name into a prefix and last component.
   Eg: "com.example.foo.bar" -> ("com.example.foo", "bar")
*)
let split_package_name p =
  let dot = String.rindex p '.' in
  let prefix = String.sub p 0 dot in
  let suffix = String.sub p (dot + 1) (String.length p - dot - 1) in
  (prefix, suffix)
atd-2.1.0/atds/src/atds_trans.ml000066400000000000000000000223071357165332000165110ustar00rootroot00000000000000open Atd.Import
open Atds_names
open Atds_env
open Atds_util

(* Declare a case class field, with support for optional fields.  The are two
 * kinds of optional fields: `With_default (~) and `Optional (?).  For both
 * kinds, we return the following values if the field is absent:
 *
 *   bool   -> false
 *   int    -> 0
 *   float  -> 0.0
 *   string -> ""
 *   list   -> Nil
 *   option -> None
 *
 * Optional fields of record and sum types are not supported. They are
 * treated as required fields.
 *
 * Fields of the `Optional kind extend this behaviour by automatically lifting
 * values of type t to option t by wrapping within a `Some'.
 * Hence `Optional may only be applied to fields of type option t.
 * Note that absent fields are still
 * assigned `None', as before.
 *
 * For `With_default fields, of types bool, int, float, string and list, we use
 * the org.json opt methods to extract the field.  These methods already return
 * the appropriate defaults if field is absent.  For option types, we manually
 * check for the field and manually create a default.  If the field is present,
 * then we wrap its values as necessary.
*)
let declare_field env
    (`Field (_, (atd_field_name, kind, annots), atd_ty)) scala_ty =
  let field_name = get_scala_field_name atd_field_name annots in
  let opt_default =
    match kind with
    | Atd.Ast.With_default ->
        (match norm_ty env atd_ty with
         | Name (_, (_, name, _), _) ->
             (match name with
              | "bool" -> Some "false"
              | "int" -> Some "0"
              | "float" -> Some "0.0"
              | "string" -> Some "\"\""
              | _ -> None (* TODO: fail if no default is provided *)
             )
         | List _ ->
            Some "Nil"
         | Option _ -> Some "None"
         | _ ->
             None (* TODO: fail if no default is provided *)
        )
    | _ ->
        None
  in
  let opt_set_default = match opt_default with Some s -> " = "^s | None -> "" in
  sprintf "  %s : %s%s" field_name scala_ty opt_set_default


(* Generate an argonaut field for a record field. *)
let to_string_field env = function
  | (`Field (_, (atd_field_name, kind, annots), atd_ty)) ->
      let json_field_name = get_json_field_name atd_field_name annots in
      let field_name = get_scala_field_name atd_field_name annots in
      (* TODO: Omit fields with default value. *)
      sprintf "    \"%s\" := %s,\n" json_field_name field_name

(* Generate a javadoc comment *)
let javadoc loc annots indent =
  let from_inline_text text = indent ^ " * " ^ text ^ "\n" in
  (* Assume that code is the name of a field that is defined
     in the same class *)
  let from_inline_code code = indent ^ " * {@link #" ^ code ^ "}\n" in
  let from_doc_para =
    List.fold_left (fun acc -> function
      | Atd.Doc.Text text -> (from_inline_text text) :: acc
      | Code code -> (from_inline_code code) :: acc
    ) in
  let from_doc =
    List.fold_left (fun acc -> function
      | Atd.Doc.Paragraph para -> from_doc_para acc para
      | Pre _ -> failwith "Preformatted doc blocks are not supported"
    ) []
  in
  (match Atd.Doc.get_doc loc annots with
   | Some doc ->
       let header = indent ^ "/**\n" in
       let footer = indent ^ " */\n" in
       let body   =
         String.concat "" (List.rev (from_doc doc)) in
       header ^ body ^ footer
   | None     -> ""
  )


(* ------------------------------------------------------------------------- *)
(* Translation of ATD types into Scala types *)

(* For sum and record types, we generate a Scala case classes.
 *
 * Each record is translated to a single case class with an argument/member
 * for each field.
 *
 * Each sum type is translated into a sealed abstract class with
 * a concrete case class extending it for each variant of the sum type.
 *
 * All the classes generated extend Atds and can be encoded into JSON via the
 * argonaut encoder at Atds.argonautCodecAtds.
 *
 * Decoding JSON is not yet supported.
 *
 * For types bool, int, float, string, list, and option, we use existing
 * Scala types. We do generate type aliases when they are used in type aliases.
 * They can be encoded to (or decoded from) JSON via the standard argonaut codecs.
*)

let open_package env =
  let pref, suf = Atds_names.split_package_name env.package in
  let out = env.output in
  fprintf out "\
// Automatically generated; do not edit
package %s

import argonaut._, Argonaut._

package object %s {

"
    pref
    suf;
  fun () -> output_string out "\n}\n"

let rec trans_module env items = List.fold_left trans_outer env items

and trans_outer env (Atd.Ast.Type (_, (name, _, annots), atd_ty)) =
  match unwrap atd_ty with
  | Sum (loc, v, a) ->
      trans_sum name env (loc, v, a)
  | Record (loc, v, a) ->
      trans_record name env (loc, v, a)
  | Name _ | Tuple _ | List _ ->
      trans_alias name env annots atd_ty
  | x -> type_not_supported x

(* Translation of sum types.  For a sum type
 *
 *   type ty = Foo | Bar of whatever
 *
 * we generate a sealed abstract class Ty and case classes Foo and Bar
 * in the Ty companion object.
*)
and trans_sum my_name env (_, vars, _) =
  let class_name = Atds_names.to_class_name my_name in

  let cases = List.map (function
    | Atd.Ast.Variant (_, (atd_name, an), opt_ty) ->
        let json_name = get_json_variant_name atd_name an in
        let scala_name = get_scala_variant_name atd_name an in
        let opt_java_ty =
          opt_ty |> Option.map (fun ty ->
            let java_ty = trans_inner env ty in
            (ty, java_ty)
          ) in
        (json_name, scala_name, opt_java_ty)
    | Inherit _ -> assert false
  ) vars
  in

  let out = env.output in

  fprintf out "
/**
 * Construct objects of type %s.
 */
sealed abstract class %s extends Atds
"
    my_name
    class_name;

  fprintf out "
/**
 * Define tags for sum type %s.
 */
object %s {"
    my_name
    class_name;

  List.iter (fun (json_name, scala_name, opt_ty) ->
    match opt_ty with
    | None ->
       fprintf out "
  case object %s extends %s {
    override protected def toArgonaut: argonaut.Json = jString(\"%s\")
  }"
         scala_name
         class_name
         json_name;
    | Some (atd_ty, scala_ty) ->
        fprintf out "
  case class %s(data: %s) extends %s {
    override protected def toArgonaut: argonaut.Json = argonaut.Json.array(
      jString(\"%s\"),
      %s.asJson
     )
  }"
          scala_name
          scala_ty
          class_name
          json_name
          "data"
   ) cases;

  fprintf out "\n}\n";
  env

(* Translate a record into a Java class.  Each record field becomes a field
 * within the class.
*)
and trans_record my_name env (loc, fields, annots) =
  (* Remove `Inherit values *)
  let fields = List.map
      (function
        | `Field _ as f -> f
        | `Inherit _ -> assert false
      )
      fields in
  (* Translate field types *)
  let (java_tys, env) = List.fold_left
      (fun (java_tys, env) -> function
         | `Field (_, (field_name, _, annots), atd_ty) ->
             let field_name = get_scala_field_name field_name annots in
             let java_ty = trans_inner env atd_ty in
             ((field_name, java_ty) :: java_tys, env)
      )
      ([], env) fields in
  let java_tys = List.rev java_tys in
  (* Output Scala class *)
  let class_name = Atds_names.to_class_name my_name in
  let out = env.output in
  fprintf out "\n";
  (* Javadoc *)
  output_string out (javadoc loc annots "");
  fprintf out "case class %s(\n" class_name;

  let env = List.fold_left
      (fun env (`Field (_, (field_name, _, annots), _) as field) ->
         let field_name = get_scala_field_name field_name annots in
         let cmd =
           declare_field env field (List.assoc_exn field_name java_tys) in
         fprintf out "%s,\n" cmd;
         env
      )
      env fields in
  fprintf out ") extends Atds {";
  fprintf out "

  override protected def toArgonaut: Json = Json(\n%a  )
"
    (fun out ->
       List.iter (fun field ->
         output_string out (to_string_field env field)
       )
    ) fields;
(*  List.iter
    (function `Field (loc, (field_name, _, annots), _) ->
       let field_name = get_scala_field_name field_name annots in
       let java_ty = List.assoc_exn field_name java_tys in
       output_string out (javadoc loc annots "  ");
       fprintf out "  public %s %s;\n" java_ty field_name)
    fields;*)
  fprintf out "}\n";
  env

and trans_alias name env annots ty =
  let scala_name = Atds_names.get_scala_variant_name name annots in
  fprintf env.output "\ntype %s = %s\n" scala_name (trans_inner env ty);
  env

(* Translate an `inner' type i.e. a type that occurs within a record or sum *)
and trans_inner env atd_ty =
  match atd_ty with
  | Name (_, (_, name1, _), _) ->
      (match norm_ty env atd_ty with
       | Name (_, (_, name2, _), _) ->
           (* It's a primitive type e.g. int *)
           Atds_names.to_class_name name2
       | _ ->
           Atds_names.to_class_name name1
      )
  | List (_, sub_atd_ty, _)  ->
      let ty' = trans_inner env sub_atd_ty in
      "List[" ^ ty' ^ "]"
  | Option (_, sub_atd_ty, _) ->
      let ty' = trans_inner env sub_atd_ty in
      "Option[" ^ ty' ^ "]"
  | Tuple (_, cells, annot) ->
     let cells = List.map (fun (_, ty, _) -> trans_inner env ty) cells in
     sprintf "(%s)" (String.concat ", " cells)
  | x -> type_not_supported x
atd-2.1.0/atds/src/atds_util.ml000066400000000000000000000020131357165332000163270ustar00rootroot00000000000000(* Utilities *)

open Atd.Import
open Atds_env

(* Get rid of `wrap' constructors that we don't support on the Java side yet.
   They could be useful for timestamps, though. *)
let rec unwrap atd_ty =
  match atd_ty with
  | Atd.Ast.Wrap (_, x, _) -> unwrap x
  | x -> x

(* Normalise an ATD type by expanding `top-level' type aliases *)
let rec norm_ty env atd_ty =
  let atd_ty = unwrap atd_ty in
  match atd_ty with
  | Atd.Ast.Name (_, (_, name, _), _) ->
      (match name with
       | "bool" | "int" | "float" | "string" | "abstract" -> atd_ty
       | _ ->
           (match List.assoc name env.module_items with
            | Some x -> norm_ty env x
            | None ->
                eprintf "Warning: unknown type %s\n%!" name;
                atd_ty)
      )
  | _ ->
      atd_ty

let type_not_supported x =
  let loc = Atd.Ast.loc_of_type_expr x in
  Atd.Ast.error_at loc "Type not supported by atds."

let warning loc msg =
  let loc_s = Atd.Ast.string_of_loc loc in
  eprintf "\
Warning:
%s
%s
%!"
    loc_s
    msg
atd-2.1.0/atds/src/dune000066400000000000000000000001301357165332000146610ustar00rootroot00000000000000(executable
 (name atds_main)
 (public_name atds)
 (package atds)
 (libraries str atd))
atd-2.1.0/atds/test/000077500000000000000000000000001357165332000142015ustar00rootroot00000000000000atd-2.1.0/atds/test/AtdsTest.scala000066400000000000000000000017401357165332000167430ustar00rootroot00000000000000import org.junit.Test;
import org.junit.Assert._;
import com.mylife.test._;
import argonaut._, Argonaut._

class AtdsTest {

  @Test
  def testSimpleSum() {
    val i: SampleSum = SampleSum.Integer(42)
    assertEquals("""["Int",42]""", i.asJson.nospaces)

    val b = SampleSum.Bool(true)
    assertEquals("""["Bool",true]""", b.asJson.nospaces)

    val s = SampleSum.SimpleTag
    assertEquals("\"Simple_tag\"", s.asJson.nospaces)
  }

  @Test
  def testDefaults() {
    val r = RecordWithDefaults(e = E.Alpha)
    assertEquals("""{"e":"Alpha","s":"","i":0,"b":false,"l":[],"o":null}""", r.asJson.nospaces)
  }

  @Test
  def testSumWithRecord {
    val r = SimpleRecord(57, None)
    val s = SampleSum.SimpleRec(r)

    val rstr = """{"int_field":57,"opt":null}"""
    assertEquals(rstr, r.asJson.nospaces)
    assertEquals(s"""["Simple_rec",$rstr]""", s.asJson.nospaces)
  }

}
object AtdsTest {

  def main(args: Array[String]) {
    org.junit.runner.JUnitCore.main("AtdsTest");
  }

}
atd-2.1.0/atds/test/argonaut_2.12-6.2.2.jar000066400000000000000000030244451357165332000176400ustar00rootroot00000000000000PKaLMETA-INF/MANIFEST.MFMLK-.
K-*ϳR03-IM+I,
dZ)$%`5r&ge&dR2&*!l];͐ ++}}z8,CPK}~+PK
aL	argonaut/PK
aLargonaut/internal/PKnL'argonaut/EncodeJsonNumber$$anon$3.classuSn@=BJR*
T!Eb9Iו;l
>6bG!Фy,|{Μ;cؔk9t?TNz*(u!},OeÓi~l/dL4t4wB9a_zR`}gyR,PT0Jxc*%T[VP2Q5܎hW S9v-↉nP`ka*͙AZYD
wVfIݦ,>Ľ>+Wr%3X$Aw~C“*N5DW>P/^ {'
6dt
} PT7/#b*M1	}K
=?[硧g/FB	oBOKdK\:W,%b1՚B@ȷJ$?c>gx@rm҄|QM}(4&AdT^JCk/PK+&PKnL$argonaut/internal/MacrosCompat.classWkW,nn5ʆqBd	VvkKƖ'~hGt$s3	[|Ы<̼30e3tbF4TKl(ْQb-'[%W\iD*zUnU
K7z'Ȗ5rbVJ"972KN<9;O}gA$Cd1ݷx.x8:YI5^9],JX7E|.EE~&XlU	JBRdA\XqA6{|ϵx_hP(LyfSq1XE~7j/
2GSYk
)&
14j"t%&m}Nw+9$B9PpK?0~avXLJiam+zLIrzzޝ.W*TQaO?H/~DFqlmmvw)Cl96Ŏ]12;̨K/GV
`@~6.?.9ٽ s(؉$:f=^q,;D?=~>"rwjLxg]q6XA^aAW4:Nm?ۼMzwfCdϢv`{GpyHO+Ko(NyyHk
z>7;)f%A{K<_΋97+)^WM?!3GzLS7e͉פqS
sek.Z>7;{蹘L7%IvSxʳK>E6t~mvLOnomcL˜wpQ\?V{(.Kwcp,;w!cWM)jRPCU.j<]wFkwz
u{>V̒5"xkaQ$j!쉍ގ}0
:/de<6Tgu?Nqzo4څ++J
k]mal!)m5I9\Vy2xC_ѠH&dgAZgnl 0uV25:l0EyuoBv>8ڬA7ğ~S0 81mH>0Tr:Mk
zسFޒFBb*#΂Db|SXEkRVnP%U1ՋÐ2/-鹆:ډS;Mxndzm#akoRnuӚvM]7Wal_da㕇p^á[J?Gpe VtΧ6NoT+(%H/mƔuVZޜ?M}>^KeTJYf$u]-JL_^Mhel˺n/(lRSĒA[։`	-(͏i,Pgncxq	;'|GW/c--$B-^]Hmt>o|}/\C>g!53oc'Q#_ FG
H
p
Wی\c,&b43$/ƫuJMuZX#.A]6踖 A5;^pL,p~о:K_W5M\
I4KA]laI@Bb%n!0L~DRJ̓JT*KRLӭfc{ܡ)#-zn1;d	؉zjJiD!hΚr6jPSBN
`S'L
4Jj9?l}mY=$%KգDY]&4K!NhgˠQ؛
Gx-K	!NDI
{GRܥeu}SEsG_Cdڃyȁ(I,%2H'ID
:D0_aTNS
UóDNc/Ĵ*ZT$j
5ͷLD~V$Sya4̯:p*!ҭ<=0ώ68Rd_YIyB
Ns$>ۺͣGZvU2e-:%7G7yg%xm!,I'.jfS="gppVp?o2KrTQfs=+|g`aoϭx8j{UbiQf}ŸvWpVmY|H6`je;aG*ҽElRϺ&(OҒts6eDQJ1,;=xS=M¢OrxE;Cw9/2>#EqMiX>&ǏD_uC1NA##g(8AL
Γ~;TGK|q%W,x*n%.!1u&y)Veެ;T˸jw&0O#V0A*EM.G\C7S.bVB8	E`{T%dB1RB&:	L&(ן{^V;(n0K#$K@tAK]b'yV*nY3y]+JDcFI9͞\w~[bԌ(J=	y~qj}.N}ǙMP$h/hkGFrCńi4UerPF2Q&O{/?ܒֳhcMN9J.N5;ԅiJْec_+Y[Qs=`ˎ
^ȥyw662r5M7S&`J	tܫ_ a0eV87
Z;h8AI?@Ch|_q)h8xKX g+W Z6({Y'ZonPhf؞?B{koBQЅcdg[8R8r?}7"sVp; _2@~[	~Z?aȆPIUDÈVXʪEJ,PK0sO	PKnL'argonaut/EncodeJsonNumber$$anon$8.classuSNQ]^ƎmA7(L&H4)0
̅{Bk_ekϏ_b&V"~՛xБA*Vg:'9o;DzmfNL77	I@2@V Tfl#r&,nm[NKBRUuB~S^ dڡ&g {!ac]_!P2kJ	byЧ2z'1,)MWAWiCOC|'n"|~>hROxw3Y#Ur?Q|_8}7"F#<89J]]>gqNY<|i&{JJ3l|=g"OvڕA-WPge%fm2]5@,EW5d
"#u,qbU[ue
^Z{R(%xJNiΫ\6C7C2uBBHmqe.r
N0Mhr$8a-Al?!Jc
KKV=2:e#+^mNTv̓wfZ*(
2>e_:{ҏ$:%}Y)*VOBhJs{V(w:
Ы%
PMh{/T\M`&Êwq;cRIҢ:M"e]#d?jPr`mSX%`ڎo>˦L84]H43/[x|('4"[u*XfdBr?wX	CUR-w.ͣz	D){ؠ
yx!
[>*azsrs?ϕPKnLPKnLargonaut/Parse.classZ	\uoFatF @6qfm{w$cm6m;ـ	z;4iڴIiҜݦGƮmm4I4minsMӦfF4lI3|}{7"jK5m+qZ$E@ovUX֖:N]Ng!c"ymECo:6+4c4ZZӲ[I"]&3(F(4.iq/)V;9QPك4b&KI5COHxBWG#䁺a넘ڸT!˃#:(LUibLR[y^.;+cHɪɒKg
Fd:{BPSlMTV41Qpf5Ix#-T$!>~j'}Ey]UU/Ht[mn,
jBT:!R(Rc#R(%gnhC5ˈ6$7cgO]ښ<GQTZTRial,)d@p9ERD|sUn	5r~0WpnOrҾ^/Lic[ӳ3rSpqEJ|	nA^.:X]z;=T)1ECr՚IO@r-帉Ԑs3.ڿw5ҬP9/:ѽص82uiϾTK2nLK	(qcY'UJIXUE>}}ƌʄA,\Rw3n{j5	;8V=riD^`pOrJ.^ƫãCe1w]\
nO(rlP`'^|ԝTP)$4c*r%̾|C)G{jXޯ3_+]PJUDr	N		R&{vM"8l@AAsrdMJ o(Ez	W\2FLudSʄ;pT;BBy~^
sgD\Ztk
(ox%Q{5*A;"/QqWQB݋CG#ӫ}_!T_tR=&#|i_73MT;t|ZM>Iߠ2|Ju_GÄOfmT.lULM~6\Z+	򌷗s4paMwxzp$zqMYf<;,,|NgS>yoWsH.Fl6EJ#}O6B/F	(dg*
Z+NRҶd$L^w~wKT|+Y(*K*
WC9EAqk'/l=9!UBITXp#, BvM]M_Iv'amma%WEPT|nc>BQTv9K.fOoYuOD(Cf S3Q8A)v&\ 6H-: 7wѱ"l
r#57LiǷtݱ⁨S#D˩ٚOfݢZA0 ;XpO*}P^@nB	\$UPͤ4!+7#fz -$D|3޸udĊ9$
E!4-hHڢ6Mo^nz%7T>j>;RN'/8Eт2&ɾzpzêh(̱"Zzmqk-]"g:,p$eD?@@yYs\yq]{kvS!4N=>xa"vrw;j/|w9ቭLzs8aμÀ<:dwbEإ/Haj;bEV[C@ҽCag{Fsw6FZ9Lr
|>mUPesylA^׻QYsAY˳.|IJdɬL/.m_Ahvak:QDK
SΎ
F1k	
1h.ټм$!"tbl'_=/o#wYU\6q5&??UENc
֑zv|U֕1vءݽ#M+VYA_c]J.F4<]v6ˇƤNJg/(mtxy;؃[q:e77ӛ"fb{#m.@^	3DvBp'8Pvhq(>&'s<[ɔJ,$1mDa)iqm}=F~w2)$1EW_w${6!`7gm_LY}^|/MDwo}w%={͎c
B2c)J"k.˽OJ.Ӝ}mZ6{xl[)B+uZ^OH*BtHɁp"0M+IBVYTYH,U*iUR>&uOCbM/b=7- O,=4c$ȕG`=ߪ&xIF#îoOq;Gqr

Q3;S{m6 vm:%o(YLUKDk`X	Z`&XKXy/wbWd}dƉ:+LVpcGjU9DUEΛԼNM-ǔ;K%G)ퟄOZXIc^@VJ8pEfE`
w;MpC"H~$Gu^3-8ab
GX+j$>Hy;GPoF/MT]ջ=y2klyg
hgqۮ\Nj7qШ+(S&Qc\ -hH.o}bwڶMc
}1c1/*շ+H!DW*j}RBI54d)eUdYG"2BRY.A:-4s 2:!QaѮq0bg
g-Zi8
៽i1| ː<PK+#N<7PKnLargonaut/Argonaut.class]	Es7H`d{$!!$Dn$Ca&"*)7Ȋ

*
*^x|LWϹLuWw*h]ʔ;z;.}Ɣ}wu^޹w[we!Uc><'ldak/3t#MM];z;3L10hZّ3NyIL?T-cɌu$v_`Ftц#jM3\bh3lt!N՜1#is}Y,r%-ӌhkÏdsV3
\xR
X2Uvٚ'~|c>9ή%ˆr̼u&/&Y2m)X/߼vLmy2UQZ)Sm&SZ.UQϦ΂:2gb蜗Sʡm]}X{Iݾ{zwȔK)t^r3>2)s|Nζ/s
v	hS^ɸ.qpttv.utz?>ne~πg3"˻gze^ZD~Oџq3A&?JP*CrTʡR9T*JP*"*"*"*"*"*"*"*"*"*"H5nkk+mNNNNvJ~ggg"ʁ.$@s -!IRƉ19eΉS+8#FG8uiqԥũKS.-N]ZJRũT	*UJR%T	*UJR%T	*UJR%TI*UJR%TI*UJR%T)*UJRT)*UJRT)'\\znce^MzmeNsytbҡI.&tbҡI.&tbҡI.&EԛQoFI&mԛQoFI&mԛQFT6ʦRT*JeSl*MT6*FQbT*FQbrF׷~@ԷڋoT9zʡ)rzʡ)rzʡ)rzʡ)rzʡ)whޡazwhޡazwhޡazwhޡazKʗ]/+ɜ2hx1p¡/p¡/p¡/pbT*1vhءcF1vhءcF1vhءcF1vhءcF1vhءcF1vND)JT2?~Jz%Sפ)NSx;Mv4it[LF244di$3M#iLHfF244di$ӡLF2th$ӡLF2th$ӡLF2th$ӱc6E\oxYMRқH!sN=şic!M#liaK[F4–4i-M#liaK[F4–4i-M#liaK[F4–4i-M#liaK[F4–N;fk7de6?)m2grV4򓦑4i'M#?iIOF~4򓦑4i'M#?iIOF~4򓦑4i'M#?iIOF~4򓦑4i'M#?D*6-e"9k,sBZfie1)HшDF$R4"HhD"E#)HшDF$4"4HiD"M#iHӈDF$4"4HiD"MV齏4>6K~@gi+g|Rq2e@RNѕrSt+])J9EW)RNѕrSt+])J9EhlI=Nf{Bck)[KZR4hl-Eck)[KZR4hl-Eck)[KZR4ȵOԷY89gY$$i%Ec/){IK^R4h%Ec/){IK^R4h%^ab^)S
zS;J|~l㉗̤+$]'Ecoݱ7g"lA%? cwp:^=/qG[؋~Xaa0CŰ04nX?;:l)Amm,+VcۑSҚE%.X&i>nL/QMUcOC|NjNٮF(j49OqOn6.*)8#a/ s][,jHqG5rpcsc\-JrϩkMQ$|8WEqPV]zN0\cL9op2Eݾ'b؆Գʶʶk9eb6bj+$-v1E>ź;\j)TӸbbڊ]j,s]+6][+bWqŦMVص\Ib{-,؄_ڊhlr-KbjvMS-bk{>W,ke^7gVc[vdL9gIVK;Bwu|
q2.u.)k.)oMZܺx[b	BkY/3pXhܧˍB_Q,4ShƫB_],)9+[RgxZ1eFn8bFƞ[L·mo2o(|YU·····݅o


]13Ƶ͏";QcnT6ÿ";|$'ݾToE|$6\nqۍ)tw[d7n1>={Jcc9_0ns;g9)sv~_.Cw*\~8yR*㛮"UP$	7)ٽw\}3~gLp\	&0ܳ1e_OPyp|+B6$f~5n,j=oP>Zے_[Cs1nHǍ'\DZ+FOh|1tm^>)|"Q2vE}^!)[ETsn	eI
*[2m]nKWonA+wfLgkG#}bb0e5vvwn0OPʔkug:M={`5KfkVZDZig_ qJTqm_ڴ}:WfvF}g$?}C[HW`>K쥃CWvvtvf8B!/x-Uc2^R-^:ëW2k1YDbEl"Q6eȕag-1_<-{q	.nl#,{qRә2{Ygҡ+zѼI07zuwg[wdz3]	msƭ|-rSy̪a=Ϫ9
٫bcʜm9|fkSZ{-gJum06q8=ݓ
(j	Uqi<߼-"}}L3C݃oy|)n%#fխd;SpfdʲI)emI
@;#%ŔKU,W.(L6{ܢL2{IS;_Y?2WKV&L.N·o
߶e
.)|QmWۥo݅o=oEY
v]V_6P6X6Tvyļw9Kz>!J	߄zwҽt	9Φ7oqg[;tMrLD4yy;MMLi"'DJwv{IzrD~y;
lDwɁ-q8G#܈u$LX9>Gy(~t\2o↢{9k>@e~cqGM1>e~4aGEf49u{g&Hw#Fo7݇/d(qэzU}ͼ?G§>f~xߣH\Go淊=t5JUk-(UX>}AQG6QظLa5GEZwFFMq3'E}"Ryt3)SQU>ekAnv-v<sV毹d6\j[|*4El\1M#gS̥"_Rl?DW6\jZrdk9%7qKDBo2З~	-oʷp/ߥ#"Hn=-3NjQQD.sk/3׺ZEZCngK?޿tQA{nA/˞Wܷ32{k)쌈uu[Յ9"5٦pY-%_|m/>{Qb볗ވ6+ӽ})+?,lS2qfXo܇֭\9K1%STWO`B7OYnt%ջ;-+.li䅼"[}|0ݟt]g31fvEY%*g:i ^_	iܝ֏|AlIK*fEQZ'W/NN~F9̟[qgcˏ*{ׅ1Of/66&쵧1d/?[8?>٘f/x6&/+{L>Ëɝ]jQK-,6&M^sgc%+{6&5{eJlLZ${mZlL}sㇿ43{i±Yًsf^ϋzHIaK&zEy0c^h⾸(Lfyen6B!Y#-3un/Ҳ r<Hˉ٤n!ٔk7o~>HKŽCђr	dy9ڳi*1i9%ry%Jo`w@)y"iYZV"-iFZȦejGϮylԵsp?ZZrs'mOr>i+}NI[哶'mO>ik}银',
>i}6umIvOϋw,iXޱcy{NJwjXޱ;lXqV{dž;:;6wli8O#@Ź_}PM趸O0v)ܕ"@),,,,,,.9]ȳJȳJȳZȳZȳFȳFs!Z!Z!:!:!ϙB3<<+yD-WPKH/DA\>XWmM0U>촴**XX}=U5̕:Liu%Op;*h5,~:kWͱ
u*PvNZ5ijAjǯU|STqlՑV'؂hKR~vvKX޸&L84
j.<|VDY,ll;4T󯪹&zz&()LΩQSCcGUsw{1r52~gkee(c2h|>K%jH&	6fƆwwC>
ꟓNSkcQs5(<@}W)ʓW+u =	
z/L;p驹v
]4k2˅y{=wy±'ԟ'ODiD,NM|S|I(DB$
iG(B(&f)ttH QD	%V~sӛC?onjʻB&FҋK/>!xG^(=(y}SSf
)J/+llЩK9s໘BcŸ"ML}ң5ML{)t^!l)KI/%Ԉyi85x1yRZ
^DzEBE!yR}V
V^ZyiA[>XunڛxRl
OZ+tJ{j4ߤT뻓BgݤVrZ 77'#iŤ͛&~ySRF
VFZ*LЛO&
7#U.xi&
=#&*}$稜Ѡ6-Tm$|T]GrM9'ޛm$xxx]7l$~#9ޔxxEr>To.{Wà8alTTn08Dol›6AL
+L;tDdN¼إx!^CG v֯xx˞x{t&h+G]ďEG#>M|H𗲻`xQ}KLIF^@#hʯ+P#.b/~rbW
W5l=)U4>G&L4skEW@3.ެݖ[Á=5mJJ~
lJo{i޿VJ
1p;UپlOó+R_y2wcƠJM(y[?P&7ทJ֝9uѷʇ)}
~p0|?$~J8N2/}ULFFiP{aQw1]6#d6Ci^͇L_14rO^yR7ٓi3zfqV1GE;	*'UL!3mo
79>Amf{GNpL*&Dؙ:v}6ȑ?7oyItcU^L=}B=99ƼF:{Œ$9jDcc2
]]n
}7O.q0PxcƬ­j=s0诲|QbSGF?Ĕ;jq[W
%.1PURb+I	uwgv
vn,\׹{1WG[R%C]Wt
+Tլ$-y*6̰;e_E/qn?XmkлUʼw0#*XיcA0͝aneO΅KvJWOgwpS)["=V-=Ur3XCiG"Va>#tf$)ЍSCh^'*LW}矄*-EZP[@[RڢmQvcfB7ɥ&&АhҐ`H09+ÄAV@[ZbtQ覠frNnV^Tfc:3InU1ת}K!:O;cٕ;8‰܇=}Tzr8: Ps*-91ґtTS#^Wu9rax
ߠGwΩ8PRM((#7*}r,l,1]rčg+FJWr\Ҹ'Y+=3V&8F,9F##@WPGHa$9Dzg/*vlMdV׃5lǯ}՗wt}ĭ;ʂ{	C/\+)%&L?4cj%}W,!PǥsYIM^m)@}N
l cvظۋVI
\;O~]^[`U&lOcϣԸ)
J.s{ө}MPS>L0mxG6F+cRٗt[q`dAf5 i3Bf3}!LMޜɴ	C 'u_~9GiF;gos]Lt&w2V1wʹr58
ܪbշ%iSaȩRńc[>SA054S?)#25=Y=nqc|0O'Y=SgO$G a7r`LAP+>حץ;.!^^=T>blØuB^Yg;bTtU֒#MLcU4zGrgC-nv*Y&\_uzSJL'uwgv
vn,ܔ̲~x:]
ZaW|WuB/(o^^kpgt]%;	ΞboΠv
XbmAJ_QQP/1SΝWwS沒Tv[ai4d|
/)8F29ԲRr3?D|S](Ka!ʳϟe^)v̛ۛ7^=q`K^s`c82ҾLgo,{3^*ݴڂR̫{3;rMB}Y9Tμoú$wvt\kdU#
-ҡR ?;ՓXٓپ2
ei^܅)h^~Z[wyV4_+(nʔM}C2+3Ln.Ƚo-l)-7uPlEUtJ+OQԖ3s3||^qܰ-nc0e//<'ʁe~BY?!G-h$:-Otzt~DFE=4zX9#GE΍=6:/:?z\tA	mQ;ƣh2NtQh{tq)SEDF
+f=Ԗ
lr%
:t(0#@s@G
:t,hh>8@'@6($(J"IvbɠS@N----ZZ
Z:t&h=,F&Ph3h%A:Ës}Լ׎y+o{o{ƒNV6vPt	hh't)v.@!堗^t%*AW^JЫ@]z
赠zǮWޘ0nNcc|_m,?Oz͠
z@.лA>Ѝ> C>(c@}IЧ@4fg@[A_Kʗss-x;>I+{Gg*Н@w:{@}mн>A?zCЏ@?=zOA~zsУ@V~덫a}|ro)|?l	$跠߁=
=г@'?+o^Oп@E@U.ؗ1
@: Me&3jfmַxZ(Li}@Aff
:t u3
T/Cu3P7Cu3P7Cu3P7Cu3ܺ3if=b1
f_;fE1(ŀPb@Q(E1(ŀPb@Q(E1(ŀPb@Q(E1(ŀPb@QllKN=w9zf=QȀ0 d]tbb@BH	1 !$Āb@BH	1 !$Āb@BlKٞw[FHzc@o17ƀzc@o17ƀzc@o:@׃a@3h0vOgdsa>>77]ghw1.ŀpb]w1.ŀpb]w1.ŀpb]w{
4tj>뛨a<ݼzuþ%ЗA@L11 &Ābb@L11 &Ābb@L1x!QNQQ\}8Gգ	ǀpcq818ǀpcq8=נ߀uaOy=kz|>5aU}kw1.ŀpb]w1.ŀpb]w1.Uq۪jkj|(>O|+/Z9th-TT ?OS[AS@SAp
'I*p
'I*p:kYT=(ײe |hٰz<ߦ6uTmT\Wq]uU\Wq]uս=bD*
/˪y8A=1׎iԎa{-jZ.lPE@Q*P
E@Q*P
.>U=-'uZUJ=ɻaJ@j*
@j*
@j*
d\Vf*39t[=VNTMfP
Ez]^h2]H4eɲh,*P
T@e*P
TxwrU"T|F}V{50կfNST`;N6j;|WR۰2WϜz!堗xe_^+;iW^:KUԗ{%]ȴY;F)2@*Щ
t@*Щ
t@*Щ
t@*Щ
t@*ЩzwST`>OST`>OST`>OST`>OST`>O[V{o(DU ^Wma
DQ@*
DQ@*
DQ@*
DQ@*
DQ@*
DQ@@?n*
n#^=ȴf}5‘ixU^UWUUxU^UWUUxU^UWէA=z#*0
#*0
#*0
#*0
#0@*H %,iv`dZՀE5`Q
XTՀE5`Q
XTՀE5`Q
XTՀE@ 4ȤA&
2iILd 4ȤA&
2iILd 4ȤA&͕ɋiGpE5P
(T
ՀB5P
(T
ՀB5P
(T
N:tQBԀ5 D
QBԀ5 D
QBԀ5 DmLzY 8
8NӀ͞ȴv%Lk@Щv|A@Ф4Mj@Ф4Mj;@;A]] @
8PԀ5@
8P
4`9
XN^iLkuȴ]
zЕt]i@WЕt]i@WЕt]i@WЕt]i@WЕt]i@WЕt]i@WЕt]i7zzhGy612j|j|j|j}tIBҀ4 $
IBҀ4 $
IBҀ4 $
IF/2__"di@vdi@vdi@vdi@vdi@vdi@vsУ<=>ixmnBdZ&Ӏ4`2
L&Ӏ4`2
L&Ӏ4`2
L&Ӏ4`2
L&Ӏ4`2
L&Ӏ4`2
L&iőL𺹬ȴܨ7:pܨ7:pn,PhJҁt)hJҁt)hJҁt)}LG7G<:xtGt,Ptx_G=͏L32e:p\e:p\e:p\e:p\e:pkfFu#2@:Сt@:Сt@:Сt[@/
ҽ(~As"zߦ#:0p:0p:0p:0=^;v7I":PԨ5@:PԨ5@:PԨ_tȋרuG7ȴD@t:D@t:D@toVLSEdZ^ԁuExQ^ԁuExQ^Itcmi,{+D> NӁt 8c^62ȴ,:,ƫs#zDu`IXRoʾ=(2/Jȴ+YlJֿVaݪ]opo=onֿoֿeO¼yYBa~//2<пIi?J{HoiKHN]ʉ0#nI*ONzfլ;Y=Bsi.ܰ8{ZyHim$VF~*ɚj:NRmNCc]T

OymvjYUZ-C+Oi<뚦aY^#xan35¯YBU۟x-_5AXε~j²[?o_;-u]ZG=up|.i?־kU7ZgwB%Qkj-w='ײ`ղaC[U=۪ZnTBi5ZDqNJ5Æη^K2zZ"ZQ"ha^WڵD6@VcJNEl8Za#K:Oͳjڸ$f쓓4~_ƾ\_R"|t0f
0%TV$eIb(ѰAv镤	M@WQP!{$Ip#&P|o~\9Ƒ(SV|*m8M^Ms[j*{1UZ3H
<7{jN#|8q jG:wuoq4VtElI	ۿ+f/
67K%F~01gH8o/e<9rˍ
8-|q*c/7p^sTJUkyΏsx<'x83ސlpυ5@a#|?g[b&ЛApmapma`^@78:'G5mO@HHI?a|IroFR儌6nؒfJn1>.f*6neٓmf`V&7>͐
n|)'Bȳ/> Ѱ^z,ٷQy W;jwܒH)6V
IݐWk|nQO^;E|,y_^vzQ}\܂Qsچu5JuXXe8J71w#R(Q
6Mܢ-dDԃQ\Ư25EeO,Ǘ"Я4tP{(\I3|9_ʙ25-$B/2w`X5wx;tH|uDu޶AEQu&ՙrw
wSy g:2Z|o AF	2N3~dg2'8md-HB["cT`>wAJ3.8]d55RZ	A[o62̷z,kj$4l-ACo7o]S;y"kifw]S{y2ki67̮)ݤ]S&	*k6Rf>lބ]S&	:k:f>)5UoiZs7k$'siI@`u2IH]SJ_v3IEj_57jdOn.U+e5B
n6ӹ8HVI*HteP6}I%i$Uܸ0
gr7.$Վ3`n"j=`o"Mr\p߯ZPÃf o[KKKF[>s,c.`Η/
%=j>&K;*5ezG횏OQ=<'$rΧпs>#|k9Ⴟs>/$^W!y9_rG9翄n?9_r	*EDw9&4x+4d圭BΩ<9#B}xsNr8[rΙBN~o++%䏃hU9rsj99rÄVs(9=gmmdהFirF.4iͳ-y8"aAxzwMYy9[s,>`kZmSdVJֳkJMj^rEn*M	!Yk5eZvM5ܱNe$Ck]S8LܮC$*ku}󋏺Zk]|3rj@XgY}֙OM*
5ewN[횪~om,,VkUUKw|++Vkʺ/VnTEuh%/v+ky@nהxlċ@/z`~=]SV_N4k|k.,$7Ɋ0<܅{ۺgW37_cZz&5|<=ӧDL`Y@[yҖ{rm9_71m>?%E7[d'~l)W|j8lغ÷;}zаuok>ﱾw>:/{B^0]\Ygl}Cqe|
;=k)'aMW#|!ϭG}3ϸ)xd #Il=d'"S|u!2>#ȇ[ې|F_k*Z ?K3K&EAF>`ךTZ|3%UhFiFS4c ҌA}J3NdQq #q #	@AFs`AF[	2I8HZ~a ñgX pB>Ém C٭z+bϩbu{KPK@-GRPKnLargonaut/EncodeJsons.class|\{{,pw	!qD@BwBdQtQ[rKbNu8S,ɉKzq;Nw:9=;v82y}e޼7}XL!,
OӉmp{*r"O7c'% TwDbp"2lRYšhaYxhRS?돞ӓMDd
䡶z8Bůj~WZsbkbÞt(~6~-q ІA}a:
*Ԡ:]K4A0Ou7(TYQe+̭j%m#eVwl
>~twg_Euian
tM޶U\FK
:+jyԉ`iĐna-XXRӆw8غӭZjjspѶUm>jOk~[mt0m~Vը:AW
%TyPбGs+4PY7JGv,
`s7k荵ZQi]u{K4ى=E3+5l׊+;صޕAGx_R5܎Swe6l?Zt͎KjWU-UoCȇk]t j΋eDWYupkBϮ'ȉkGN{f9.ҳ׏G6(V5U,17ex=y-EJ>f,.Zy~kT4֬PC[e\m몺#{U":OKK
5
4idTZ	;ciVUWrV(,+lpRjQ꒶~O;=Jme~O<+5MAt95
u}AR&rKI0շ5qea֢3E=\pm*Z6al麑לX/X/ء:jWwRuր{/wc-w;Q!*mY}}>cZ˂ibU)jUKPp&&Vj7Ou.U+y(j67_!Ep+TJegᶸ0Jq^ʂ	4r_#
Zኽ}eօP[SB>@Пx?g&
SI՗-k|<lKH~P
[ubeЯ1Tw|1w),OlC%R7ieVZY;ƪ=ZSo/٩q䇪(62GE#+=}Rx^M
9Nme5GQ:0*
Yy/.QiX\L(_wrJO^+|V.!}
GK
#(N֨{$`Įbe=6(];hڢTP->O;ωrv]?iIdžG#Sx
h797
$?5`ڧOEm8L ,o?	4#sgT|26&cDz'&sr:ӃNsw>g4wXF3CɅ	Qy]':#CѱMm#Bh$98!MݶѰ>G'rCD$Cm
\"MY*G0u
%2Qd`u5 FLB6NmOYdFHUª,	זC3ue!fQ#
]{:nd
܍ЮALu
:aOu4<0:&ll:ܛ~ZC&"dpB8B5us7HnD±xld:HZwq3?x):66Si 6x;c[`7(?+G&UP\Gi`겅}:&6j}KSzs.B8D4w:MC2#Tѓ<ߵpKc\q}7z<t#f;3zwvJ;p͊,]JZd5
#觶'-z>"Jc߂Ж%aT+E`Jl@}1B9x~?`ؠe.Tpr2L:8){:<tsU|[*sU&r4~4CXh:::}2>PYQ6J ?E\鄿%<:Ⴟ?i:|P:?}(?g
'8sṆMy716^L15:Eh,DZE([_׉nzХc5,)E^6:Fa g1ef7[F8@ڒEVV'V '⒋6u6}ue.\yIevUz]==:
z00':qac67aO92;#<%^l$؀,B&9"z:3Y]ʢ'6[MF
p-H$3N흎'R,\qd6
N/nft-$&JIߋiʹ9%"#iIVf:^R:v6AmGXD$"(nY!ZxC;y:V|VY
O-k{a5X;XSϼJfN<#\n9?̺xIմ
ϵ|h.3C%"Qps'n7+)	<0J#Er)Joyq/pINi:#ٽBjڕ.45!(\9Ϭ=WqmNז*Sa|-^my	OS9͞R^/
Ge_f9Ut&™yLw$Ȧszi덤A9zNq
٢Gp,/JJoJn=E7I-LZ`=8J3s?:p"V|W6~:Sj@>τg59kzN‰M\6ْ)n+ދPм~kG"#KN? 5 <֓C9B&y-F(uǯ;Ôjz#sٗqX\23n901ye7:>&s:>,s(}<~\^(9Л)+XsSNDμ20[Dkqڅ\]bG-9vC'MNR	ϨE[8JŖ̲]u$}_gkS8퍌$lp5ՑŧiH1v9}G5F
.*e7z$\bM\*釃N3d)WG#-xi^\f'ی7l+-bڢ|
ka:NF劖3H6lGv"mJ7W|}b6dR;+p]:hb~V7<&}J'+T	V庩~=@1gl|4rpes̅1 1vP<u6
lVYnh`Si8AnR	^um~O%R7=g&g+%ya	X"7KED!|B"R3n|U/ۿW)mj򂟷Wt>ǟ~@?ts^+dOt|̟~F?w㏽dt~Cu^:ǟL/w^Xkdu3ȟIr^]A,?)yPd{>ӱ#KDݩ+.Kc}h1L][^#8»Uvҕ2w\xw\B[!<٭+KJs
gլơm~]VVo[yךY(¶gHWz޳A;.slOYzv\ޓ_#SƗo"
6"&K6SZvΊp*xbR8mm`RiS6
J;3߆+[V/)?R[_٭UӶ[_pK}.XvSپv5uOKuYس]^لdW7>{3_l#R${e>Շ>W%D7ds+yb0gVUE|N֨)'lQ){gNng.ٰ%YQObgfqb:YL#/,֢h,"#J|s&d}/-K;nٗwB$vJY&س2FM~_I/=9gɉyui^R9iMS./ҼHyYi^:&%59	`Mq[Eڷr)c:!8W=6
R=d5w9͕/LĔmӤݡ~Tnh'OOEGyE&;FSSjḱ a.ou芍Қ#'E<@1c
ڄ_BoL	*!nj*15uX:Mm֦2SvkSiiq&_%ٛ*7-TijimZfj6-Xoj6UzM+LM֦iiiԴTkjTgj6CѴMϭjXCO齝–＆Ƈ`,ThV."4WcvS
`ezanC˒R|^#QLeS|xX+~r!g*>M+PIq
	SIz2DtiWI{?kz?FWޏiפ_kzޯ3%Az}_fz#
~U2l˂6Cۓֈ`(
qCY*INi8xIP6F6.x#ɰאRXuN3D
+JRV!Nähq@2[ˬ{Yk$l=½YhNŠ20T,C 10;0{_fͤ,Dz2ÎOƙَtO[SiCU5R;
&Dm'qTbg)xi6p7fHNZycA2oY_b+9fp1;f^ُ[&%Ւ¶7
׼ˉyh
wyҼa!4#)4J7&̛Me3NC)i9&)3J3,CV%|9|]7[GY5c-ﰀGw]Yߑ;;-V=x/
I#}xeGyҊ~@3iQrȹ<$p_?j6H',\_6dۗl=1_ۮ#/׶'l.iۓBW=#l&ٹlös9BCGY@Yv[_iEّcA[]?fGV?㋶osLc1F0Jb0ôl%겠bA:C;w?7{r/dvl=suXlQcf(Ƥ+$Ee[8՛k.b

T
.`(TH, Bgk3
e:\zؙbɏ(c
F!h?})kIڐANF
$f6I;ڇiZ$i1hGSG
گ)گ%
Ki/ž$$A,EK}Ɔ6|߰N:lcXƒ(;2hS,%Uj2Fv{]6mh=dC{$#3)gړ6}ƾA{}7EA{>E{ޠ`~~ޠ5EA7횒H*yIl:a)?L+,;Hqwh4Wbw!ɧٓdݳ/H~fp*qCBEP>e1-	⫢;ʏT~ 7ȏoS?#C䇕!'rmȏ!?G!w&',E /wE1y7u	%]4z	VyE~Dy3Zȏ-ZR$M~&o]Ok?q(.ŭJ~_+rq/="zG޹kQ~i,x-zW\^Z'w ćC|\ >>!w-jA|">t/O7&eT(?PKˍ$OhPKnLargonaut/PrettyParams$.classX{|Un$IMBJyliblJPI[PiMvv7UADP*VDP|"oDT|AE{$44_/g;su{n}-BZn& seOBD3r*r=t0zn'-X/f=M3	~!ۂEd.[Y-8_XǶ]+ u{1ȝ1T-~:\q]_6p,Z@sc;ak]0ʴ~|n`eci\;sbmclDf{K:iЩfmOKYcrKo2ܒl%)w7Z5w&OA`t0Fn{2$ۍ^X{_L3>" zaw$no;HKbI53y"Se'Ԗt&Sȫh1ljY8|d~\Xd͛
j8m,ùz|:#^/{-ϥ36;1иlmw3)qj9,Y]/_4&pMIBhb׮l\j'&t=3K.q.D:GCqt-Q_K.N)7)unBN5ڸuT%\lMrK0W٬89,o|8؈Mu~4@bB3h-8l4q!]L3/}fşOfyfus8s8s7Mێƹig0?'s1!pTQ7۸
Ċ ʰM;n$B9\5d psm%׫T
4oғE}WIGl,-|rR{yuwTIƂ3&춋~W0Tp)ķTmum%-U7jn½,$Kave/,0[!T3E%ŏ')xףLm_t&Zx\EO|_R-Of&S+4m4՞UQx˔a+բ
;uը
 ˇ.ozbР
K=oFzod@\r[ݥ~؅}a47(yd7Qݙ]qltbnyX;l:ܬYbjxYl9:2\H|px_؝A!9m/ÕI~T{t67mK`1C+pMDe3gQ)Ԁ)/+8%§bhF%:f0X,gYjMUrMnBxK܊y{'BԕBmEEDVZZNGBNU}x !\Ѽ^ZD29t%ZWzH݇܏O
]nVafӂml^(KT$*V*QN&1=QϨۏѵ2GV N\25!i"HUjKdiGT6jDFۉiOhh!OTQ@(ATWt.s}tnR)E^Ri)MN'y',iN1B>\[⪍qA\Cz
7BzwMz/>L(zH{Y>>~ۏ[	c	aa8/Z)l?re7ga_(cp؎xBG)Wg:lnwk
p֦A|A|YZ15p[q'*`ڢs*~87>;sS~1nїUBCxV;i~g=H{q0G
c=`D\۲Ϣ[3(;m֚rSYjygEiڏn!<0;ה:\e/3ylbnl_bq|)Fhh+2UX.l`rrqBSj~qOӑ~܍P#qtJׅB:jP)T
әUYPKKz	FPKnL#argonaut/CursorOpDeleteGoLast.class}[WX9!@ mAҩRniJXZ;VWH4	]:Gy<5kNiR"߾?`AB{@Yq޸*}Tj$;˃^qNi+ }\F[fMVW}f[SK
ds+eɵknT,38{%/Ž<0ypr֌#DcO1y:ZAVK&y8Z}v|t0(Ϥ9pȳ)hҮkZzNNnx\Aeܝ%
"~[PΦR^ya&W4x7Gԭ GrJRc?_;iU4cy<&U4eqQbim!)pɰMծ9YVisR	{)*[( oԖVԖTqCdMSu.LJC.q`@OƉE}?^N绯cf-2+M[:yQe
2Q<5SGA&.s/Q=)Xj*(wŒTkw|`Zz"XV2݆<;Ki#}B`!>Hq*j%EԖCOkQޕ3*canY.w/t3luSeSJ; Ȥ8$,_ҐxiYD]]5YH٥.Y|$jmiS<  )]`aVq;BΖVȹ?Knil('y[+|cdK>KNº->AR,<
j5JFC5Ƶlڶ6n۶lQn6@vT9)D'b>}<j׾~sOȩ|-mMOnz쫆zW@3e+
Iu>դ\`dn	? ?k~	~dZIDG&vE D`2chsv=rah7P=ƅ	8$M`ɉ<x	<	@J5XO''9x	H6@Ak44 ~1/-PK
{mPKnLargonaut/El.classWS^Z!!V\e8+$#"aJp0YIV$i}[_:tvifzyigҧ7MLa9]g"ФVKj]L dZ+W*nrjQ%֜T#m6FZpޛ%	’I]MC$>}!QVx#H2Ii?B;$.l2':|!!E}<JJvelwoFsqXDy05m#e}#6`Sd$P{SQdEY_+Y`OMxUWٌ;^ S/wwytnjK{l5KrN]]deYfFjKn)UVɀWM)p{L6Ez؀H9uj
n-Zc$5%Ih7O.n,wR3R)X]%ψ/Xy}4
XںnG򳾸bURڔXE'&;}.u[	#OJC$X>ZnDz*"όKE%2v>N]̧:=Hȶ&VR4vm"6)g["%$%dba
t1bR7hPIFGÈ{?l"eYޡtmVV:wC㛮T+:$IyŢ(Cuc$%*P<CvU^?KR
A
ņT">lASTo8S0 \?mӌ?#yI#H)+#0~O{cn@/'M>#Xk`2 ۍS]Q3g;w7o`»
æ)̺˜)6EQR;p3Mw
h<CCp}
0s__0ܣ;Ҍ `61E,⼀3֬{FWU{^WZo8M=q|n8
__yt@=ϲ'XQ
\;Pxz9CHܿMT>?{)0($/!cIGpLPEjA-|??<+we0W`F9(ߡn>|(
z>hqS p
ܷOp߾w
#}#	!(skya>\~,tw-%C($MTHi+8C_B Bߟ1'3g?3sMD&1B͆3F,3rgԠ17cC֨%/PK9CsX
PKnL'argonaut/EncodeJsonNumber$$anon$1.classuS]OP=_]PYU6$-bhdQ5xwrG_ 2N+Й̜smlDJ$qG 
'jU@U4UD/x;ٞkN`Mh(gh(1h/+k"҄
{Z3?jd3'P(j'Ohz=X4P-BiS^C(N(.'c/"^OpL܄i Lt&m@Y>H{^xWCj嶧xe|8y(JIe$a_24`/H2I︥|>>|!Y[Ɵm=ę*0>WNҠh)%/H\]f^2dZ*x8ͪ_~4z>	.۔R߮Ar8Sudj01/E[ٖRJxPKgPKnLargonaut/JArray$.classUkOQ=.("xUhPy(㥬%-_H$1~3o?sw@Z&;w3gn8^2Dm[䦖f0l1MrJkfux](Yyװьۦ{Q(\iꩬQt3KmٲLtq(6Vdhܪ Ġl":Qxy%M2ixb!^h@XC91mx"yvJCC1|o<`W)2[oj-$Rɒt{d`uOlz߻b[:
LCC'> 5(@
g'
qQB=~E]!Lj}k$_ Eo֋R
ښJ}c.m!?z1H0CXLcZ1nY{K6snx#n4YWJMݑ5gl[-9<_u6*uY{wxAwuƹ!e'ӮU:LSj-g`xĢE'T_t<FIZҥѧL![0y譕){iF.?`ii="4þmSB~НZG+bY3ܾ@xߠT(IMe80}-hҾoZ~NNmlAsiּe2E\>b&WbwG
y
G4lJR &"ߩOOq2%6JTl!2K)#,Qd톓Xh6JGFAy綶nu@H8إ&#<2x^_&a\?{7k!/"c"Qs_$Hh6%M˿r))4q!L ɣnk7kuBe85Cl.Df0Kp,~W)aM0X^{3A^S1sdzשz<=))_`aaߞOmPqHżG|8da0q(QEU"҃L]wD5x^4
FF0-pedÉe\:
r1[g!QKa-rE'=.t)gGҵΠmMEMMGاSj#|c!ֳߧeG-v"yB.= 0V,,.,QUzb>fa	~$4XXܿ\k$&y[Z}UoQNmmH-*:G5^^6a$ڦ*	ײmj#۸m۱]G%۴Ss˗OyDW{򷴁V0MR9T
fV|	ś'4@L~=0	x[qDa``pq0^1mY;hb/QGM8Ըeaxy`?;Pt./8l9.H.s 5Z
^	xELPK^PKnL)argonaut/internal/Macros$$anonfun$1.classV[WUN.Ls\L Ҧ4mERKPztL̤}CW_Ude}:Kҩږlxytǒf~UVde[;
+S ~^q+ҔyayFMˮȊ!ϐUۚ=TwLeȗjet3MY3(#{HuP;c$˦>#pp4DN#l"HUZmhj|ٔ'e{7`ܮ	^]ߔU7@OLnq3jI"@k
5EpoT'vE5-;v_% F•̇W$L !usoY4]]n;ӧa	HcTMiUǼIӡ݂Ȇ%1bQagXh=m
.aL`TU
ٶ,NX0몒IbqpU`k۰|F.fOrh~xPH ,yDu2Zݣp601
|uUR'16KptH)oNsJ
}|~LL(nVXC<*Sq}lhm02̪Q; |:?˶؏;Qڌ=VC\9cۗgSF~;
$W9;{;|/	J墦JU=+Z9sM+}7&WJV	#T͏hY.1z;JQjY^ f/uB[J$NhK٭Jq>0rv0%DijEhӜ Д.cyhurLsbV=Ӆdd,ASQofKOY  ,hI)y(3W9r:Õi*p0Lf"ib~_go]^/Z;_*qJ믒&z:ھ%Hϑz[~ ;.#cvkCNA|w%^g'q$?&O='GiAXh}	Eu(a1wY4{m'wylҫd  8zL9zJbsyFM,Ƌ~ˏ	,V3Zf	s&($GYGll7+dṛmML9y-&)^cvz`W ^+Ց;n6>rvZ0WG1sICB"0;W}BDvY)<}q⃘yAΕWR6!U
zScBq)_Q[ɯY̛ڃ6D'EZU%p(}KZ׫ILW4}hUjVhGG 	<r@8ՍũJo5Жwe)c]9mz]/:3";Nm7b(rv(`cBs+\eQQ}	!QvcA0/jI~cj9!Vl@w(>^Hђ;zYQhc6pEŲz~"ax+=DUUWNh\+Uu;VAYbWK\z>VV`f>)ĵ\d3p@g3(+|Ek5w „C&5n+$Qg#eIЃUB䴒q8"4~Lyr	~
ҟXafi gra3,|
–m#59I]9J&B!
pX'Lnr@t%W>&ũ}l(2)piPPTPj_⅑؍9 9ß<p]xd샢̰*v`4.}nZѹ!ZTNew(ηX|,jyWD7*M"oMS]i
%"eKVTyz'fCtV>]naؾU9yU1xkiT(f䛦"I%DRMLȈ(Չ-@C	{8O	Fށ-S|(PAÖEoL!<(pYxjBŜ?pv%3&$|(taϏoC(!Ďߛkvac1GbZ~jF6&
/I;|(Lԅ´km(Rtaw.J1F_t
ꦱx\?Ҿ?A=㭉隬H|y,m@]^
X& wY#Ua9ÞPׄԠ
,k
~Qv,zk<[2?̷%b#M>ʟ#B÷ab62{?9.s
Ɩ5P=N;~
V
0U}S$Lj~.}W5(&~'cՖ?xuG{xǦގ0EYL;b.VO
f˜{,&fcn.s	jnS3pi0!PKWVPKnLargonaut/CursorOpLeft$.classT[OA.Qr"*P&A}ڡ,Yvp;kO_`"FW0".
n3{9?}&0!}L4eP]e5c?VĚU
qX=ΐzZ}Q)
R|=x!=Y\US\~cҘY88z aMbm1+
/xoU
N!V&-ǁ69e.봤IF*j`qW~].OЯ7KXWS8pڨ/5Q-|dp,ւ,J4D@iT/f13N,COT
)qJ*"\%`b:qn+D$g)kRSL9WԼ(!t`$aRƺE,])F(;GI׸_zr//]Y+2#";@sєm1e2ԓ$tc&tƗDu._Ă(µ%XOSVd}|M̼
Z?Lg^AM]rZI5Tѱ4W1/dM:+2wut*;=]@7q7pKD`=᪒&[l`ek;xwAob-ft:AE:__Л_y+3QB[n7}pAJ~55}u%;P:İY%nͮ;AfP^=Z.>Y AzetO]W2~=lWkڦq5)Л]1mCmú;eВc|@k5榭TW:-yuhj?ӜH04958٦:	ʲJ.wnQ]4xl(5Cm+7 ]ycܶxq{`u/eY>E>-D^YgsYkx]?ƸSnB"c4'*0ǟKwq.1&9m"`_qleTč88&z~AW|3[k;5DwtQ!u+x1n@'6]ۅMmZ.l؆wrqǽr<#H%~#\t]|PK+PKnLargonaut/ACursor$.classUksI=
L F꺊J t}՘QH4(]!c&30XXj?jko7#f'==Wpu]ܭ;6oyS-i
a9i(75`H6kpMn%Khք:gIB2m+2D3cUXA1v2Κop<
s- p[k"q1mN~bg1UI92pЍw8І!QhaL^!1pTPP;ǰ'3櫵<+<ifc
YJnL!	qa!>6UA4p([2
KR
%38+9PO5\`89jRU1d"'BPE-ϑ`tH7<ӱI=2}ڠ-slY)RDoZuPG7eFoId
b5w3pX//cp%!9д*}p$X]j>,!UNwwagɴ\k}Id,Ug6wK#W̺ͽK吂#˞x4Me?luLHrkbTW$ҬMWB%)Jb/ON8$FimMV/4HTDkX6{_.LA('PxJ{G1BPrF
$pxqb,M'^ӟ?O2
^XT^F%gJD/*pGro1E
W
bU*kjI
"M
Go[kVi5v@]ڈm&gߠ}G@! Q,+-qJXmUQՈuT3IXeaEF?PK{PKnL$argonaut/EncodeJsonKey$$anon$1.classT]OQ=m(m*U+UDDI	rnMWHe{[443;3gX&H
odٵ޵:Ntd
IBvW\VZ)-AƯ
"@_0-j!#=W&!hka-kb);„@i{KH#{	AiSb'yv{>.%9]#a6??ڲ:;M-#Umr!E]FpLL`Rye[/52msȆGNSayT<jU>RE9}[iX[Tlimv,k	U^e}r
;?h/bݏOd
W=Q;neA^+l*\unZuopZJ0ץՆh,6e9X{O_[P>#SDLmK.V,%4XrS$>fp40ޱ&kZ	NN^S~-K$)~go\JHbx9PR!CdOoӹoNQVhc-!)z; P	<B286ʾQRL+0GPb-Cq}\p:PK*PKnLargonaut/CursorOpUp$.classT[OA]+ "x]`MTK%6CY?/M4[|#&;9|ߙ3ק/! 2*Ea[rkc޵Rņ$ás]>gp,WˣCn%tO0$ic""}[lDu55C43}4*&A;1Ժf^]*i	|o3QWN1Y
ѩE6+.wꢥ<88p(/Q
Q^%2!2$+MRYK98'$M-9FS85.KaEWr010gW8sw]>mAj#ZԖE1F="HM&E::%qy`WJ{ʡK.d<(?Soϯa۱fy{}N6D'þPƂhK7M2,um)ݖ)%Q]W}*rhcUHu٘!$:35:lft/(m`M2SD9E7
n22! q>#[cХC
HI)s[.0w1"SNDu,35shEg	[>02OF>@C4S_C@ Cޣ1Mȣ`/Ӭ2092]71d]-47$^ǘsm/f׷+Su/=n:uҦޡMuu͎mbz=Joc.I̙4.1QøL0TL#
10s0.JRT ?mUUlck*np[B߼bcsi1p<Ԓ`9l7&=7A0;
B.O>>b	Kw4̥qixH9EH۪$Ȫ,1mGuV2d^Ǔ`{/|Q_}ө)4}^ӯʷN]ZDH[JIFC226`)XGy0O>[b?v'211npS^I(bv>s'0۩m֋3a0˪~t)l)O)c0ϓ‹(+Rd/` H"RԖy^",Nk6UPKX{;PKnLargonaut/CursorHistory$.classUkSP=-	- HX
hJ8|R"Ӥ8#ۨP@3d{ܳɏ_"I96{[sGfsܷIko\qe({
!5mݵ2xd&w|2(={|GR(>$"e˴Mo!J/1D15fT[StEeO8&cvD%y@ .2sNc@;Cb$ZHɔ(Rٱ,*9R{X9hC)D.jH,uA*H2")V$G60]NÈa4
5Ub¸CoJo5C_&W5ڤ9Ad*hRmNhgu/q]3qaMXWV׷toY].$%s^ݥ׋?ߢ?jx^}3EDXBޡU;H.gqURjޏI4kP0;[~Ƶm»R%J [MHCc~^w,
!Oi<tȑ"ŏ3۸i&x0
KCO
Xl&zJbPK:">PKnLargonaut/StringEscaping.classumOAgcDO

(iqHS6M'АC5}ዾj`77;;?~Ux0M~5v[~gVDku̎
$&=+ԣ=9!S4Ϻ2Pkvh
.[9%5~>_1Bp0PUwOKq+!~,m+:
!Dj%mt'*'rrzc|"YZN0dWP_N7RbIZ%Jt,31tDzZ0*K*Y7\EJZA)

ˋ}\ߙ\j/ܼNh9ϼQհD$%IGĄb%kt[0xPY'eVgr^鈸l*>fҊJNxNK>Ro'H.5eA8Amzk\Q!X5Zi8f{N(ثշrCc# ø"vRBFW@wfl!A0?RAXJܸyɊO4ʽi
,G4ݾײjvNYǶo]Kw7+Y(:c1;ü8(*}[x) DđLe-08ZSn4uŻn|v!"hq9pڪp9(.jlc}qszŒ(s#ߘ
.a"4ڟ6\T'
&65/VAxrPK9TPKnLargonaut/CObject.classXS#u?v_5WDK m, x#ab4z!fq$v$I?]٩*+SJesnK0ЬR>sw;M(e3FZyj&
R0[P@",ƾA}fj^(
8s\4	avIHYf%wg7FSQ%hzkDG"hq{N0z)PĶW\gՈ'M\|?f٥jL]͍-%[`+!Z)8	EƨMkQu2ZS.%<>,mg%C3hGn{ʢ{B:ajfyUyoruA#xbPzњ&
q7^vΆ7G^o^[L7Hvګ:^17;붷6K|P[U/}ޖލ{iOJ'\CM)uqmg'pj{%g55`(Mg*uM-^VasBGvWTcd2 ѷ
{$h>j7ڭ8Dɛo3E~yU㜼*[r+6u`̽7;x]s檪ۤ+$%"!zHjvy᝻yZ'l.u==T8"QGxaSAȵ.I<ԡaAhSjQG$hƩ9GܛxsУ]Ey"Ҥ%Nѕ^AjF)ΐ!uʤ{pcԼM\bH譚~=#~hnP.ǟnbhZ_L6埿cXBU6q'&xhlJJ۸_FXHuFw-`J5I>"sCLǽ	nY-^<:iZ3	_
`LӮДtW[]>5T$-(x-.?;0yO[uFRik~Q92fNfغވ]zD*2MsRR	kqsx7M	uc'Ka6S>qyRCHBXxjm^~썿l|eR	t,Tm㡊ƥ\1u1@Z\`a:H{AUp	WC3gmxUv\FM_u:tf']hJVlhPϩ+3LR8AF
:c',
is	]eڵLMN`@!D@.>I\4pwy,l874艙/]SϹ	eÔǎ"cBu1-ܣZV8MgA'@sCʊѐ^(0+%9Lm"I'	Y^u,
b]3eH5aH}@.W/
W0\![J,j,\H%utJ6Z_!Nf(2Պbn\KbDzGr)
l;٣l,7枍*ṱ;vx:_.3ReK飤iAXTumFƺ&W"}Xϼ͡`29s^=
O3	!idq8|25_FMEN*y#s|_޸_oocq"d=.|IsJgP?(/!}~]Ȑ_UVfuA
|W
zc/zk:=`2V̖5N߿x䢁"HZF]h\4v4.G-/NYȢU6v&ΘwK;fB:L/wr!l\EKZU	wJ~?[*$͙0Ϸ\64ګg2YvD>F&Ia7;{(x!ѥRVCxr;=yᛗ.^Y	/~9Ш쓟C40a2`>[pO {@	-ˋZqk1>%j//ڭEn-*	ҭp$F/(Y@O!SX 
8mP_lfпo[動F(G'2οU5NOp[kyp"XlOcÉSϒO-%;ܰB!;ϰ^3]?˴(/eX3kj%k&`%(b\&j 9ܿbVj r;?,bVab@EYV!6+QTMkJ>D"oKm-OA|n@=7DN'<> >!*Yǐ  m\+*Vzy:UG~ڞ2aszZTYe;WPT<9&~5*	TO&O&U)V'6@ZS"YeU/4"~W:>r&#|C>#O\.Z"z.ZEYh}mڅ?G
	AK$<&Cۭl[-Z:YǦuj[aUM+ֱlW"9PK6EMPKnLargonaut/CodecJson.classxTy)Wb$QPvw@,tvGB`!Xa!,]79cljknkNwO\c;ql'qKWB;hf6f}ΌG?ik~XNȟZyXoσ
!Cksk_ȯXޞcwm-kED%ε/8cZq9ƌeu+ޘ$^q?GF[{NΟEKC=u"՜v:fl5of3CWݮžt>`}9ml/9Gg;.g
f.u."'ͦsgW<ٖͪ50/ǔi+ipaօ"ԧ2Z)'6MsLy`Si{v8ͦZ;:PB
t^an&sXT={R)jfnuNwZ'/ݓɯ~N49]5?/.ֵ~(j"OKMgAؑ+O5U/mi+c\6֞[0sL޼NIșTFj0W અY)=%Pn\]~Rbr6[n^[KږδRiLM+rΚf'4|ʨ.9CmdS/;rT6\af7Sf'M9iw7ݫ؃Gvt[5?9M{T*e}/z(3i"5gs^Uж(;[4{gZ{r;{2gђͥm\_&4f,! YܙJ]Z2UGY1;:m/r3.n
:]1/ݽɩ9{Ω9yfT'rZQNj0OhXWO{PMB̷ݜՉ샹@yq64f:!n
N͵Ϝݸluٝ	srsTK'PQ}Ksurz\;ԌtKfͣG4=4N޳bC֩^cp8e)uruG[Pnfغg)s}dVS6]GeVfm{jRK~\WޖJ5'(뷤"=ZRټbkoٟM~$74j[
1˝NNOř\c*m>9으TMt̛u-S)׭o
fp6oOTjaF?m=guu{Mui˴.R/چy>?0/8޹fY=wh^>Ѽ
	y8y蠍y.ֽ˜3UZZx)˜?w={wpt?G7	zc:Hw4cM&NCr4z^E/Dh^^G/tr&z9^|r/Mmś6o:Ǜ>o&{W!{W!{W!{W!{W!{^WmU{^WmU{^ɣVkkkѶUmm;EnѶWmEavVV]({<<#¨߾sþm]-h.1ZڛR!Hlj50+sD;2lRcl@6g yp^t8/:΋Er+r+r+r+r+r++++++++++&8eWQnd$k'9:939=7i+ҐW!HC^"
yE4i+ҐW!H6&MZ9r6il٤I+gV&Z+++++++++o2^m&ʭ+̭p@8ZmInM2irfrfG^O
y=z*T멐S!B^O
y=z*T멐S!B^O
y=k!k!k!k!k!k!k!k!k!k!k!k!k!k!k!k!ka	Q[ʀgd0ɀIKLμY!/B^_y}"E닐!/B^_y}+!+!+!+!+!+!+!+!+!+!+!+!+!+!+!+!+!+!+!+!+ơ6_7<%&S
 SIVJLά2v0ovwkV2V2V2V2V2V2V2V2V2V2V2V2V2CV2CV2CV2CV2CV2CV2CV2CV2CV2CV2CV2CV2CnSŴ(8M|sL6l;̫gπa({B}bLDZ;qq0̗(2B==&2IdNpr->+>+>+>+>+>+>+>+>+>+>+++++++++++++*>#>qD?@kLt6əyJ畲+eW>}^)RyJ畲+eW>}^)]qqqqqqqqq?MQ0E9[Ԙ(|JμّWp>|^y
ϟ$>">ŢQ,Xt6)ə'泶泶泶泶泶泶泶泶泶泶泶泶泶泶泶泶泶泶泶泶;//F[1Z|q63:=^<^<^|^|^|^|^|^|^|^|^|^|^|^|^|^|^|^|^H{.40:ۄ.ַnq|y+sW=^{2xe㕹+sFFFFFFFM^N¹
yWܻ~r̫VףMdqD8"Y,HG$#dqD8"Y,HG$bA,fbA,fbBɯƿIRgųmxv[<-s9lqN8'[-ds9lqN8'[^Ѡf8'[ߤE=gMh
EBQ(s9eq8GY,Q(s9eq8GY,Qc7ysF\8zJlrh˥-|
h+-vCšPmq8T[-jCšB^u`0F
\pL@-P2L@-P
!RHR/KHKHKHKc[
M}Js1*ʧ|-n˧|-|;|	_2{.{.r)KyGyT/EۡXeWnsqqˤ[ven%_\3ykNtMM\
n6nko\q``6\x[	W\@

paQZw_R]XUnx?gRUx6PcR|Ea,]R3w=3Ծ02a|5 #=w0XrՋ.؆&W/
=7?4{̐0*CPةsgG!.L%a,/͝
>WX=jϚif:j¸*% F2vŗT*d6`9wǤ7<q1LpXh8@oǶ"7%%aLPU/Er46(9qй|+'z(^
&shE;f8O_Kǥ8
J'ozKeֲNOsyΗ+l3DEɧ
*^R΅aP|
aj2יiv49sITF&~&s|4{vOƭ2;enm@*J9cG	UC.
aj,g1F7M5E\Mkc+2Ϳ涨#/#
iFKKvatQ'TⓎGϝq;?+&ܚľ6Ub6طľ-%=Xbطľ%,oW}KSbKWb.o/ksݝڻڻ7woj޽ڻwh޽{w{ڻw?ܾ~L]#v>Ի>Ws?o~>)^_^Qt5^5]e*{Ʋl,{ͦl*{l.{͖l){̓ey5[^5^5^5;^5;^5^5^5{^5{^5e.{;+{DGJ8-	cޡGOە"$=(&I6ƺf\s	$J*	ܾR:꿗FFu4zm}(qm5&PCB
	5$p+%![HUe{rST$'Y=IV_VO2Mepqxu%y8ɺIM'VȠu_J2
Ƞe`BlrB%y2ɊIVL+ewl?L $%Y+ZIֺYR'@@eoy`fU$y&*IVIJR!COte겁;P=T0Ԭre}"ȕ6Zokj&4igB,ȓ㳜j.7?$PHB!	\T+IƈtTsNݓPBB		%$0p'7*0'7]g5\3$YyRRFD$Te*=_&q㟌Tݳjn'1y*S5?o𓐪xQ2G9:9ZiMv#|tg%s2*=)wޓ*>(?+?(7rVzRʷn'yvQ2FJJʚzrQgy}X?Vޚ'y6Q-q'~2ux2Ѱ+$*/K
]ؿוD[>WLTBv}\sύjO+OmQES
8h﹑=Myҥj%EwrǶ:1Ģ.,al][*KK;:ʗsJzQwc_;
#Pߩ}}ȭCh7l@?㧅1)޳0aF0xm6f.c_~˖X3SLʤ2
LSfrfJfjfZ&iܕddfegܓ7,,̴de,,,,,ϬȬ̬ʬδfq2n f2k2홵u3drLe{aċ4_dHo0fӌ`\<|ݰ{`²"}Ű%eUհVa̅y0BXl
v?Xmu666ömmmu=;;K=Ʊ>|5j[އ+Sq{Ga}a`Ӱ3sA<"1%؋aÞ=	{	)KaOþ2aa앰{kFz/-j +?߰qka?I`F؛`oao6a3aE/{7a>a}!e؇a>h?0>9?`n-
{t3j!=+_S_}o~[߆wa,a?sþ"aS؟K/þk׍oS!oro\S
L_	{?a&[oþ.agؿo?aoӄ0	S0
3auz$X
k5Em/i#m	[gVw=[]aa3`3aͰY0!P@u!P@u!P@u!P@u!P@
0'(C2(C2'sx?qZxmjcZ%Z%Z%Z%Z%Z%Z%Z%Z%Z%Z%Z%Z%Z%Z%Zv= )pjoh^/.lE?zxvvayQX$$@B$$@B$$@B$$@B$$@B$$@B$$@B$$@B$$@B$$[qH+k#7/7P~[q'@o&@o&@o&@o&@o&@o&@o&@o&@o&^1ثafhFfhFf6{xHݗ}uo:,.............q9n#}ulms!n77Ѷ}	'a &b &b &b &b &b &b &b &b &b &Gq{|A|q=ƅxr]vaK\[''q'q'q'q'q'q'qoa_}
XGuXG|3Nx/;/˺~,}pw	pw	pw	pw	pw	pw	pw	pwIpwIpѽz9i^x_7{,.]JIɰ)i0p'Ip'Ip'I!QDrN|g#w։=]T{O2z
=(1r%D|TO$L$L$LÒ}Cn>.ˎ;x<ó\a(	(	(	(	(@u0u`43J/=>{ 5	R 5	R 5	R 5	R 5	R 5+q2i/{2+];	`@aA(J$(J (/xܘjL=<,}yIK۔rHPIPIPIP<JԿh2)YeyW6Y$N$NP\EHm`u=	3j,_RXKz둗`/={".)ґ3Fa}hٗK}:.,,U%=Sʴ@}|MR%TN%TN%TN%TN%TN%TN%TN%TN%TN%TF؛`o$O$O$O$O$O$O$O$O$O$O/֢2-\{/	ʴJ0YG`(%R(%R(%R(%R(%R(%R(%R(%R(%R(%R(%R(%R~y`_$M$M$M_=RUca_+******6;(((((((


LX6	G5Պ2H{*
,
,
,
,
,
u+ԭPB
u+ԭPB
u+ԭPB
u+ԭPB
u+ԭPB*Ba+_
`f[LG
o2@
@
@
@
@
@*u6@
@
@
@
@
@
vºa8S8S?t+iVL+Щ#0ФM*ФM*ФM*ФMa`0p*p*p``9S`9SO^ӷFV(lʴe^{R+R+R+R+R+R+R+R+R+R+R+R+R+Ro7[V.lʴ******> @H
@H
@H
@H
@H
@H
>gn2~:)
d@v
d@v
d@v
d@v
d@v
d@v
d@v
d@v
d@v
d@v
d@v
d@v
d2+q}f((lW\eZLLLLLLLLLLLLTyiJL빅m#רLkp7jp7jp7jp7X#	Ҡ)
Ҡ)
Ҡ)
Ҡ)
Ҡ)
_4|љ=(eZGic4i8qLGǢVҘoJ#hdY
<
<
<
<s2NP2
.2
.2
.2
.2
.2
.2
.2
.2
.2%mS֤ڽjʴjСjСjСjСjСjСꃰG``(|:}i=XxO?6NeZ4N4N4N4N4N4N4N>U֤ýzʴ5jP5jP5jP5jP5jP~
RӰXL\?^kT5N4N4N4N4N4N:Q[*i
^E
^E
^E
^E
^?{)
}yUiv;`4N4NB\Uk
ʴjjǵ}ʴXa=?YF`I
`IWRʴO%HI͆2$SqIoǥu\ԿU+
W
߉2WQor%xQGs#Wuѕu˖?oGE_a
W5ROśB!./_*o*%ՒEk
E?,-#E)7KV.6._݅^ʾwxheM7[GLT;&>kJ*yҫUSf1*m֙%~Hf]\t9y]?Øglxh:47ŜW=ɜL\dUhͩqR4g"|Osyw"E5*zqaJW^8p%^^i|\Q_2~>{\Uh{"i~NK\t`^[Ywt:s=N>nlo>0Z}qHՍ.?bvItH}8\
ߌ\~qT2Ø[m#܍
i16w0Z|n*apbHeHc
]_a 1R
y,rhC8P4./w;j摑"Nf~ٳf/4|px?y`~񿩱/ia)QȚ懰iJI7<O֘Yi'3b"@qAc{L]d0;7RX%GVwSTK3@q[EIZhEw潌OKʃh\4b8t?.)m9Bǩ$vLWQiUIĮʚBJן&?e&/z(w0\ŠXwɐ?=z>xSLUP|ĮAjGwP2X:ݩ8㹉sD,h?U4_pW`ە3f|"x؄'hG'qXIĪpcLgŅxc$frA-\pd3DlQhm{(vu?FFcBK2)GZ
AyT~xKB/Ꙍ^4xBȔDHp$ȡYj02:!
3]KM=u!kj`uԞyueR,Mwr.̷ͤiytI"'.XSRVif嚇VK$o=ِ>,
q|n9O͕bB}Vb[K|RNjkJ)AbE.h)DF4iYjj_EE)7w?9ڦFDahnyVtg/%
Z⏾7z"~XitK>ZtB4IO3ɰgS+1+G/%)MEc/1Y
˼zus_]H9YDM,2Pk=uB8G;UޅYgSҮSb-N]r>6ԆUO+O^s@Π55f)b
@rף<:T|It)FhZ[_>:Tcw`7ܼK^!Z	9
L-y=s$iסWS:{f}EȂʣq+Z5ƍjeQ4QU_)a;P!ޑ2ZBj7,M|6{?}=_>ъRZm^/A;!|{sj7'GR(hVM0ESw3bRlLVzYE>-g'tJ+i,HB0-i
59GB{dsBO#W	=߁AE5#J/5䶞&bڼdY&ږhlsOo9ȀV_ܾaZY4|^VD
q}o㵦1G$,˃ٕX{QDсH>(c8!4BˌU
]VLiIlK	LFӶQm޵+܀C/xxޫJ[D2SaIR6^!X:-2V:"w pF;%{r3N?9qؾσ8LS'qH'1S
UJ#Y,AѪrC2ϾN'?ih[Ōf_QG3CWY4mH6}W39Q{Nƺf-G4k#eLzO&ϵiiG@?'4Mq[mwou[Mx3,S~Ab?'ge
x|Ӽ=6'GOĤ*v,7;%r\A~,975^f-2QZU"F\`GQqZ1x]M3XcVvHec=\1dC9b1eu~KGqU$c߂FLؘ?P[sQ@e^HA7L43 	uR8ؘ}qL7(YDM>5yq
|kqτ|Jx:,cccl`Avuw?ʊ;'1p$Cv>'.āMo";gzoBج|݄qpX$(Ŏv{SF% $_ {UcbDFg+)"?dA):I`)8sXg"-ě^[E~ A`Ȑu
X/
kˠL~_<3\8$*LRǭٟ;xZnFD.+gb_oز*vUč.%pgb$pe3`\tbBY;莍=iNj #ﰚ%?I~9ZP҃Q܏RW"zNGg8EŤ#@oПL:@1#t&}ן4EtolΆ	Mp(8>(>l=#)pZW348?lLM̮'@X\ NHVp4`"hQ=nv0%Vq,\C!i&G*<'*3^maH:ʽTQ
o"MxcnGFCq{0K\B3mKwQvy9|!XD)勍mR(_0|4HY,^YFe(	/{)*\z,$lאoEx.`腽ҞXEoxQ#
(᭲pFB;LSǤ@ϛ/L	mI;NPɤg^4JPTkg!1U8/J,Dkف*eQQ[8ʉW(?F"(/I/qiCzGT{p`
}:'y/O99;j8_噯lñT@eR&T,gaU6T~\S#-:B`2W
ۍd.qPay7O\t$Kͷ{fW~ۂU8+"=Уt=hG~dhA~3_EϷm[utݤtݤ I;7i-
ߚtI/oM:
Ijgȏȏ98 Y a89@mfp:DSo1ȏqP.`9qy9,PfVi%"?։><ч?&qI;
nK	)ۏǸ0eq
g+:?57|([ldwJ0i)LE4Njpҙ?d8+qEL6sH kB6U%iXs</wl^i%]N$g;+ΎT}e[&Z`y&%HgƖ-il8%#l"Th]#-88-[&I-t&}wJLto<>z>t}C]D;qCOY.(; paAYl;IDi6J;4i- Y&[4!pR
IrV'r,D@892O.Z,~
)9r->Dž+%
lx ^V!Fg@&<;[DlwQIzC\dYN87^kAw\BIR܎0L]27\YXu:3s} }Q
&fg\[puks\]zFPV*ݤ3T(2άR
ܹŸRΙ~cY}Y!|g֗(,ۚ#8JϬ'brPuJu?Q4HϒcZtAz2@I|7g
Eg=MEH&|	|D;&2'ֈ~'ZPg}I!G1yϡtOz_	K'@
sMlJP>%ҽPGme[n~
r7"rRǃACLc{
֧Ctwm
"n7*Gf/I_"$n}OGfMgpOd<̍
i6ވPƂƐs e"6[09nۋM~ȩnvښX˭[ mNClzcLc-A>7QzyDif9l'P)c#.2#ؿH^xh`_8MW~ۡہh~PLˤ%Mz
]I6yL:0IGVLzIhޤW1锘i&3l/
^r@}_n?FIoAeHv<:G$(r+ѡr7\x]
oB
;
M[o3&䲋}24ggpۤ}nDIʥIqP0L޿00s#`p8%yw ?(U$G;(w>عL؞j͵ݎອ9C|vgǯ;oppwy^|ӪUiq:dUnryNِV;ͤ+ގd[+&ck'i+'~Nro-[o>3c;ra*61_P.̕
Ž{֣
^0֣Ɔ
̘qg+C6noBGYX&M`=z4z4z4	kZ'AA!Y+.P
[i듸}!ص‚Eڷ‚‚u%r5۟#gx1%A!#iw%QSJcB~C|<ޱJE9{"T5X
閮/7,?Nf/$_F_˹+w>4!vsqOoLM;Vw#"nV+-^-[wg.%Kb,wcbPP8C!C$uG'Mlʐ?dQ+y∴$)hp+'\T5ieykxi}kw@7i.IMi}?Oi}O&GDDhЦ󇄦eaY"nb6hA(~KԢFzAA~W]QEx0Dv
j,@AvI9xZ;|
"(òcv1C~gcJXˆ ȱP!%>5AE%=:%A
rDadldYnanpIO$@JzqEu4YR.|2>+odkCLNyY>(_BY/5KyUvTʑތR-&g+qenDWR~ZQOjr_
Qny?UЪ};zA3=oJkET>ߔC]nJ쮴"]0r*jrTCd/Jyn#w!'ucCXG56<4;
%;FK\5pnwj7C0?~ؚ
\kw?ȸx7,M^LhiJ3|,j49Hhwר7bFMdQ3KF]_0^["eݰP&`g?xKލEN8$I
GGJB!u$W#D'*D|EJ٠R*,"xc
V\)$|X h rEQ"V`h@"_\h xq4[DUQZI}=Aw4RkY e/Y4uuv,SsN.\*zCeeć))?gkE+x&̜fU
3彚"$){·԰\'Bvkg5e{n뺫fDiHbb ̔٘n.(Csoҏ]h/Ya43#c?ˊt;[Vg?
ǨmafEL6ܖ3mU%#tch\PT-Ը/(]$`Su-dq✵39(a6D\~e46~!o;#%4qAG՚|j[s,+Pk2'eUo,X'7LTX󋩧!xχ62xpNE!SX
	D~hϑjn9b]
R_ O!"jHj]!/M8&9PDGgq8CMR-G"c:ta9FGSF	;ofJǿą<B= uܠta<~48>zG_wď’c6t u;:p5l{t`sahIpC1PȈ@aQh38}Meq_F%_T*uNdi鴀Uq(pLOsG1	7]B5Z86nHW89]R'qJQmO!o8*JZ<$àoPl0^	=;
$f R$-|m޿B(u|n)V[ml5<V_0*=i
w>U_vx}?~_5}^ݞ*|0ݓ[855xd=GA-2єgh<ќDw|ׇCӕ'قASMyzfp]
.iRXƍVZJkq%)u0 R܌:ő~A";p
QZUBVN#jPhi*@@B]y{Kw[MQwf?l)%vөjaſyrU||j
ba@4
R
SxPvȃO-\哋~/Y9!
̓q 0'pP!U\d"F t,AOF)GqE[z9ݸue-
lSR|1q'57<,2c;Ww@*ƕN:I_Nr7n'n/'9U=1+ȦF۔l>OFMRW@VZE}Ze	\2]\2:V)VVcU&-jո{IJ:
.ZI
m,\/;WhGʻ.
۩ܻ1wI.~E1П;6
DJa(G
/~ޝe]ʫa:d*Ź?HjnHl2Ϻm_|<f\xq%nEXXgT@HnU\.\*ޔA^\}sy\?7o^ugɎʆ:^\F+5(H	|Frq
jI=I^1
$AIg}j;|@.3	jf!~hX0+EYf<@hn?/ފkqmӬk&K^?yW6Uq[&0](c$ߤan["bed9X\녌qyfLIwLfgn&ͤ/L+Iv3n&}SL;:ik&@xsPZn;Djl쾽Y(QǠY9jKlٰýwR k7<_˸q'Ż;`#oV7%:fN)	l~wn	q,3%Ci~T)(N~)=$gQ1}!Nn2M<qǁ9>П/ .6<qr}@xіOs9>ӄFoSquOuBqUy'j0(؛qRROu۶T	
[wx;prpJU`
wzkt7}6-_ϸ/3=]	o.JamَRX+'%XnF!\⮍h`B߂cm)޽%f
d0S%7&?C/.1|>%./.ˀK&2	Lp`c|#o
p'ktfׂqiv9w&1߽x&͔6(/w?%,0jmmZ85>?oyr0,u -zovftؿmoO?K`ϴ{dz[	6aQ"ЕD@
_
|ֵ|Ԙ8.@;|פ epWdpWw4՟t&}thӻ&`ڤ#@6

M:Isl=d$!5km(ģ_꜅ynX_s{;LUK+g=y7q{󪴽p[pʗPxw77[GX4-z@yVXiZئn*%e}x]PbY6륍waVAnrB0 L|	
`0~@4&q!gċ͍-Q@`"@cyqz'~]|	'<^j-WuO}z!;~|{\pp_x_62vL8d,;y{~&/{qϓnK'׿Z_{O=̷ަi鯅(d$(HTK%(HT{a(䗑(HpQȋޓBv4(ĤE!ǁ9>П/&wh`}_O0n&]F@ߣa3yIjSCR[Xuaϲ2{9 :GYL~j0"Et.3겪S}ZtPEiP~pa*۴J>,%Hd'PR۝ޞFk}QӒתHm=.YZ\yMQJse7Evc}QUikΆ@;ˆ{ea#mdQ?f`Z>PP8Ԯ 3lס*dI@RAȏ41g>͔;J"V^́Mi^Ք-Dh{Rٽ&[xyuuS)nr+7=QܦOP,U#wz^V?@Ͳ	uP!
#f)/w?e>u|g8qZc, X"`w
GAs­+;gE
ڮᳬ8LlvJ2ȪB]PGy0!qg!qh3HL}O84N_07W<_?('<'vZ,C?6^QlQCb
P;
gu%d@#,3նoBʲR*[}'Ae_?	EZ9P?7zy=t`?E8,gCH+p/}U+K[>,	&*2	9X@d#$〗`~
'oC_6D޷1=T
=RrC!vCGב#mODy;Rg>sB6h/\h-8O'ݩ'1,1+[;6?k",U|h#_$/lC0ʰ//aTa_WDpx,"`+þOc>M-dr_M{u
(yζ+l_~5e>هZFȎݷ =}՘"+#.Gq?	"y_ow~ywy9il)ա*Zψеu=SuVb@\?DG?$P(H;*tRe!*fHj{e?'۫T8.g^BBe3E,ErH
%\!$>;+A&XQ~m |=#*㊘4yUE򾍴Q|'|hh*RĊos$>
\wCTXorUX?¹h뮚=DU0F!$ċH77iŋ*FdG>?nC,^DZ9HHZrϽBD/hYW"1]21>jbS]tT>Gּ
Q$|g-v,t"6bK9T}/QbL"8#T[Vb!>{7U询g"*? :/cWpo1w0;WaEG_	O8Gl=(v\("L@PCq"פyʋo(V82tlʁubUlӢW_'NK:O[.Zf;иqgii[cyCՐE
Gsqݎ8ُZFkQ`2.ZŮH[%;^Wfc?~=ߥؗϑhbmE?nGf:%]ylx\iCt/"zKZy۟y8{6+5U_WG
-@b(J#.7		f1W1XG~
%9̿$gb#>\t`mӱ.>潅Pd߉&YʦTp`_A`/̎{h63:|}}!P_,+/2[GARg".쨝6}F2v	1@>CGEk8*g8*P
G򐣎Տy&3
tlHf:s6IW؏~}WU>Q"[c|R[:XwTor\GY\RsWՙu}wVU+v7*csqmHW=u#z
}Zy_ /2 _&9bfC ҋUOnv;wlH/O	Zo8DDHo(Bg/QUi8s@.k#-TcnZՊAF"d!qr;K
C3+}uϊ>!oJKs)1-icv<1S_W,gӾύ]}wo(B(mJa޺u3_LV٦C(fnn,VPb}K|A`nG%
2DUkObnb>
G[|7
{P6ڿc>tZb>#?csAi,>
R	 G }Ӏ,\'F/ꌜC2x; =>C~g^4owuF-lۙؾה[K/@UѼl2W'ѧ N
(\pH_wA=!Pu2F
F
u(UiHY"h'mcyӦ!OdyʻF kȣ2DJޑhmH;r.٢>Ks# WХ#{Y;t~XhE+33=jթILҵjjMPvM>V7?.ٟ::=_W_,ZzxUcPt /F)Q WŗQT!jum@bz~T@_-Nԩ|7I/b߰̉pƌ{"w'Uph*m:AlAqj&}c@lW⽐x:8WF–ѪOwrQ\5c=fbѸer	|{G`w4p/Ip.)[>?biT>D$~
CIdJJ"yg+|de;8O}CDeyT)=DH.$_믗CL@>~=gS/v;汼gV<{4.hߑxRiAۤĥń|rs:LլtIv6
pb#A4Z9faj:6^А=VW϶>~O|,%0T8hTtŦʭ@WvlR-/Kr"WILVjD(kQWSp6Hח϶'󵟉n8znZ=KNJgyR什fMzvϝQb8.VFbeMl%i[P@2j+11ʨQ$bd+	Ji>b
+6>?@2:.Vu
y*.V&$\FCȫ%Gbe3#GP"[+qa'zbeM5ffZ.7
034I;(C8&O[D㢱
5jZ03G
3Of&@03/-ᏤO`f%ڸ%4Q/1@!ߔ:1e'갑ue:4ruYE
7FX^y̐rؗ!Ocyމ!/^)cygyTxM\BK6frp6
ݵ	w|/ΆS?:w63Q=G3~
z;9OnZt-}rvL=ߦ_5ΌLS1k;ۗ܇aVYr4!qZwg+@9v2KݨsA[[޾uC^-ݭuW<1J󔗭܊ގ0^G=AsAχ(l?8ÐTV2;NG]Oט?Xo{?cc	+yƺfo	/0-7i4q~jo&Kߍr}efm Wl\_dT0sGhwayTɀW8xjFƶpK@մFg%|ɗ&M՟GKOO	=OCF&
W?IgP6=wAǨ5	min,ZHEaCF{0Jt8;l7:lp82&W-a|GȘW5QgOǁg
ԯq@@o?kX,>eT_pL}mI+sL_trt[_m:XjM#>M`vb"|ra`?%i>B)G
y#nKhjg`ݽYc${ɣyX~	G<.qhqn܄,~
%X.!zn<a.Q\vIg%;qKĻ%O*D6W`u.+6G%ڮ[iL
:Y͞L,Ⅿ/1
}z4WXՃ۵5ڷ>+zRַqw,9׷%7	g%u6(;G?2IkJlI96D2Z2<1ܖۜ]
Eef[]Wd&쪥tqv/?Z컯).^y@jjޖ&g]SiYqyf-ydSqmU[5w֞R5Z˜ojqW}1ky)QVwӞ⸬aV{hOiPBVΘ2wwm̘3-ζˆ6enIe̹rhK捃(1M=`L-,K͜8`*;hO&6_oͷo|'oGL>O1Xu=Y@;`iq׻Ý
z2s\8Tc8=r*zu&]a?VQgBG4gxِLKyOg[5xj <
q3CЕv!dpekKXX&v:s A+=`\ә70|mLof"`0;
,٘g0ЀR=t;.1BJ+M8b4޴gDCi|qNz68:*1gkW9\f~x6;	f&|g3%W
g~w7oONo}f\_Yro}}6זcZq}Gp}Ym_\KWbk>rtơ4-8ohʬrfvm9|MenQz+Z{CYSXZܹJJFͤ^N켹e:뺑uo/|PJ=})MǸoH6W;/o`w5&z7ybs)q⽻,e_QbiN0..0RXz[Rκf$$e]MÌ)Ci쎼XqeȺ0Htk#O?dz|#O߳珰ww5<7-|(ޑv}>(ޑS,J̞LCé/+ݑZ;NTsv;:[uw{[gm!%&<V{GׁlmgXS,Y;!/]@rO)=Pt:)
y8Geq9˛)qVrެjz.sh="XXN#fmP6Vk!89/޸=,^t!o&=)xn+nve;@"GgGV@ϰ5B\4io-
śSQMx@uWave֍V8ZxNz?;铯}UBxy<
]mx}Ga}ˣQwyחw8
חiط>[io}ZSoO|	(Wqe`vTNl((k}F<Ɔ0Z+M{Ge6Zimmru6gU)괵:GZk&F*\whf;3;ǝj56O]{=]ݙcC
Ww넧ɡ㗻*=GN
]}xMuv֗91
w6>z0*'е;Rm	nV3:;wy8;#=MWUwkzzJ'k'la[7CzmkgCOx}|>"4Άew&Uqv|v}|v}?:F}6>%q(wU(ۥ$go~7ѫB!6(*4Ѣn~Ͳ8>zUhwǨeS=s*=5G
U뵼fLU!ϐ7~͑B5r*JWg)1JawlW@qgO==uۺ^zӫB<^VH礪Ů
z,}<`O~v\_Eo׻R}1E4%Ww|x}8/4q;u4V\}D'uS߳{xkھk՜MI
VvѬxښ!U!#}UMUO\?9:P20spgD#SFu/j$q
+$؀	dÓ
ozhrLet@u'n9U!Q3+8aB,]RȎsݤ$8T.BRt;%#A[jKЁ,K2IB697~|LNd$
I)
%͋NZcfzxb.v45P-m;02olcxfb#Ld=O&rQ/&YHB
&&'LgWȮ%|7WW#./!20d-B#鋢+_c`zolcFꛚ'.H+Lxg''9'qYaKnxL@PB<}x:d%H`/r__՗mA`9sL3mzڑ@ڂF=wQBJko>p,~1.s6l)vޞ \s1:|^z%
V餽
غ:-dBΓ|
/pˡpG[怒yB=7^COhס@^ar!hdq1/A2ﺀ,Cds8깸"_f:D!8n10rE$Tbb%r/1	"0O+[E3Vb$UEnsIW唊_RoW7K* S4sf=́*/AQ2a
QW#:_e/Y,
%(TjĐ'TWmSFI)K%ե7i}+.ɘŸVS{!ճT@nP
yN!_+ꅮ`?X/Xܝ8
첆7dM%yඤZ1Mܟ׺7(kZ9,}8?#?:F_*J⚖4tU`Us׏ҨWŕ-X*5
K4_sR캦P(P:/JȟιN+(X~v'#ek+u^CݻU?TCܼY[1XY=~T^/VIĒ.b]kyb:8:9ϽkX_Fh%AI6X'wB+ɊҪ;{T+Wp0n
!j&pP쓢-kyb}GMVNc-ʔnܡU*7yw(!(P༺Md/Sd%	J1e挔Pާe"`C(plZnTTК)x4wCKYQ"rZn٪ъߜ;RhM!*{jm'L
ڙ=t)Cˑ51v$)aaWv3Yyz'*т/v|Cy5LbUArPQfuW{+*מ;}}N\`W~wHye?e-ORz?U;Qއx2\;v!fܤ(yXC	d<|ՠ	\s8q)>i-Owpr'].!Ё&!
S@ɸ$t  ʛuH..
{Bt%	؏;;{)/hE
IGF=wrbfooʬx28
pzuppI/pON6+'/G/P#-PcVNfllVNϩ*UפE"v$_"yi7E"|oKE@EqˋWijyy"yP|IȋfyPW|/uዼ(-"u__/Ͱ<'j߄@BB$l¬Y_RGD~!t/~/p7>B_C!!/pBA5^%V*&wj)h7+	s4YU!r0<=[ijjOV2}
řJ$?gNٗg*W~
);lVtJBF^bTh0ـuB!=M(q_qw$R IbN]ĸjZD+K.K_]q.&642Hr<$Cg2S1]̼0^/)vCy=7.Mng/I9SjTZ(ɋV+F5H%AT7+R*T2jM+BԠjZukYŔFu'Up݊
]њ$SmW4h"EK+|CR4Gb.>U%3D}x.ѫ.*>(ŭjm%Yjj{jARQ|]~inVxCVt.dPCPX?{+VG{tOտ'X6-m1,06U/k:A2tf_W*w?3*֢^uGJrԛw/ԥef#=;;*oZhVoW_K
I
NFE_{oPOVF;7Z:MNoymD׀K׎Z;ktd]ԷӚPd6Ѐӝ_~JGۨ]U=1=V/`5k*K;pK6@,p⃡ؠ25FdML\QŇՇ(,QG:kab胏Yza^|1ʸ|lV5Titn{()tt2ԡoVEYsG󊚫YFѣV{uX?0QPOv麥㵢Y_RLw_	uE^v>ƾ>N{ƞT+utVVA}J:heQߡDF&c;7ҫN>|V6'! {JzNNEqenRm+f_Á8
1XRbydjla.^R18ZvI׮K9NqBT֤2QZbfU!#;nRHrIvm	ܫ|wrllͮ?2w`lylS!ZmX*K!|AX~$6ϙծz`9׀ʫqu@wRFH{tށA薒n]SA~mT?8j]s5`d4oFmf8mL얾+'$exbx282+	f6mҦ
Qb
^f4	2vu2v*e(:ڭ&6J4kwP0oy朳*ik֤ݴs]F-&n黵]N}Y{=K[ۯ0>θvmgyvANr۬}A!@@szT####a}s^QI;Iwv$IcYIрUG_ܿjr?s;1j'hg}v	'ˣ-'g@ա^{Z[[[[[ABQ{ޤ@Cx
4G34o4_B⨙[%pq8\r.9aU37F&+4WhPР^ABzE{F٬F7l8 s"sɑ9ȜrdN92S)G#ahq:f2bLX^vї;=!(}y@tZlHh
vĿK+S!u:pr9\Ca} Uۍ_H/i4B|!
PЈAPE(4^D
T>Gn
evY]V.+`c9F&C=QO娧rS9Tz*G=ސB_LF57&c坯]JAÐaX0"?&#@ pdRT /KRT /KRT N_ڙJNa5Us@{Si3R_jHA=$Ja="GTr2^o2***********3ӗCL*p/>j"P*z|jTTTTTTTTTTTT=IL5Wjn&qqqqqqqqqqqqq!rm6|JwH7([F#I瑤Hy$Ge|9*sT稌Q2>Ge|9*scLjgz2eGҲZҲZҲZҲZҲZҲZҲZҲZҲZҲZҲZҲZҲZҲZ>DL]=F_LT׳T׳T׳T׳T׳T׳T׳T׳T׳T׳T׳T׳T׳T׳/sTlT,{(P\,n$[-uK%qݒnI\$[-uK%qݒnI\{ОkQMQy 4/wҗ{CQ}%}b/}f85D`Б@A d]2.dK%Av d]2.dK%Av d]2.o__ 99ƨPPPPPPPPPPPPPPPPPPPD<sD;gp@@memFH?G|Q?*2xok?++.Cms9:ʤGG+2'8|xK~^/t<1ѱh]c@hcqX'o@H%)>/cqI-:M{=qtH>'+_)gi-/4 _dGO1po3i'ثy{5cw؝j^EM,ң*.f.w
r..MU	P]>sW)= =(=$}P&zX6Nͮ™r}BATpkx;~Rmqs[\'3|D+'H r	2$'A9A0ϬJ™i0<0!̣~n"?QMp{nQL%Gr6 ۠oCrmXη9F+c,ԟ]"^~Cx;~5nCM&{d77Mvr^_2){wP!9{;,grטYd‹&7%
NK(8
 Gb#q#1̑Hr$8$yNkS甯J`PCr-8(ׂaȵ`Tcr-Ch23q	b܂ )qb(9!NAN0'g3sr&89ߴ7mM)Ӗ*ˠ\YrP,re+˨\Y2.W<۬(Ikp\m4K}\WՂ+%r
+א k5|q9_IT_|)p';L
e\25"QLej\.Sr|Eb2O9~NS>OItX.#r\@:!INt4H43E\#X,X,{Ղe`%Xv
e`z3=ƙLOp'9SCiL3N̫S>ϼ:3R5AxDƣr5\'j<)W)taCٯ}b|G8[M#~ FW݂x )w)1N8'?ɟOssgȗ~NS>-Aɥ\ڇ>"Qɥ}\.riK\ɥ}Z*퇥;g@eTOm:jH`gH~ "AE9(dX$ȈHQ c"AyL	2Oi y9 )[~_OAy?1$'ay?1"'FĘ~bROLC~bZO3
G@V=Y.n䚢NĬdl
K~F"E
4:(hXшHQFc"EM4i4OiFy4:4/I9w:Ng@;!ysP;y3*tθәw:NgJw:N簴әv:Gv9ASxĴC
ٰ6^}`zol}'G*;|KB<@!#3|&13gj98ٿol=2%`9y@]{1olcxf/f)+n$a6*+)y
TzP՟Я%
tz@boo|`f`01<47sdfuˎ`]/1POҹϹy9	Ȩ-se`^~~u_>S;E4W)T9
D_񈯸*sŢqчh-+%hu都w^4MWΡ4.O؟R>Q&켄	=g,	mkFkքZǛzV6iksv/

{|TP0/0tXzN0/[%Kf%zNs,[ECEqq=eq:*[e:0UzNv-lB[wE>ťByRf=
zDlӾ	u~a39=VaJgqUs?B,>1XJ%!O'Is/Bt,NYzeNg<0노YMUKU:=0/DԹhz~ocIU^bBratEZGD@	='oZZtFZI)zъzN_,*Q/g]VCVҺzN_*q^/bEHc#\Syɕs^(ҋjՋHRzNuz]^u>r#ڙpxi3KyNMhKTg߁X.9<3720spBLGW]c}<#3W1119GKEiIİ)C
Q}KH"QcOW
b,-+%idb!ό$dRc@;MkF,,f,0#mYl%4&R+6Kژ)h UG!XnU1Kv7Uʧc\1)
-MhXaN[Ym".Dei&v"Nm'm;QLZD=$
B4hao`&ܴ	7mfVhN$F	DhŹ^щ$.p5Wޗ$!	}I¾$%E23%? ʵ5BGnآfߕ<Ō]1cW3
kB+JT-:@LHiRt*'-4-eJƾ%cߒoط䠾ل`}&6@)>lѳdߵ|.Zv-w-u2u.V)&!2-D<*:} #k*ʘ}Mžb_SԠL_vZ!k/8KGY-UvՂ]`W-U*k-
y1
|N:!]6iyQt{:=}OǾcӃ/A2OAw{wXGU3Kz_eb׭u+v݊]b׭u+:kZ1RŬNf½>a½"\l1ɇlbXl
ca,6ņ؂b)Z 0!a1{\SlP2hK
`()J
`()<zZRP,E03#¤MŞ&ǖ6ealY[ƖealY[ƖeV!AGi!q@lYEhS|)-
CK04-
CK04-Z_I
΂[_`&>
pO sMN'l栍9kƚ`9kƚ`9kNPaE~|CY81{FY?ԛrhkf`jf`jCeqR,XyI?L~|S<+
e-4yhs.ƞb{.ƞb{.ƞO _B`ɏ_&P̳_ϗD31L=C31L=C31L=ZC,Pǂw//.D
|g\< C-P<"C-P<"C-P - &}ID=_(	
[,/o"(E6JRd(E6JRd(E6JRds)XEhKlgblNX /2H^"<'D-4L6I>j6M>j6M>j6M~6;0S$Z>_YI"Cᠱ%̒/جCi֡4Pu(:fJYҬCi֡4Pu(:.
kZ	HW0q&.2F. 0
-BiP"-BiP"-BiP"-BiP"-ҲhY%3q[W
`xrv\䊅!YO+0ZW uj]ZWuj]ZWuj]ZWuj]ZWuE

P7)jI,-yVYwu	J]R%(u	J]R%(u	J]R%(u	J]R%(u	J]¥fh%K'e%P[6yr1ےO+s+JԾD+QJԾD+QJԾD+QJԾD+QJԾҾWȬ}r>?BJ-eV9/R/EKQR/EKQR/EKQR/EKQR/ҳk"e_	IЫ\' _`_\RN+cic;zaG/vŽ^;zaG/vŽ^;zaG/A^􋄸WVHqeB$E	I/.)laiQVhE9ZQVhE9ZQVhE9ZQVhE9ZQVhE9&*5ٟv>6FdJ9$R\lRO+	ƉiDoq7NƉ8'zDoq7NƉ8'zDoq7 oE+bH۔EҸ@R*&-mVyߚ_clBk65КMh&fZ	لlBk65КMh&fZ	لlBk65КMh&n
kZiI+`4PIT'Lr/>liʍiFrWnʍ^+7zFrWnʍ^+7zFrWnՄH|E<IvnU5ϭ=ʻŭni]ISw*%Watu1e)SIfbLLfn76=&-* [:,@E@G 	#=$%8	h>"58a-t@\nЧtGNp@wnsaz}Yဎ^Уa+t@V870}yy9t@W8+az|y5t@_]&z]p@O	zrG
знzzOt,8g=G&//{+"A~пp@18	胡z~M$L@?_^@+"7t&L@\^@
/V8п	?'B~&Љf6L@[^@'C
ۂ}\="z{p@٬gd?)#ytl“@V'fU]hd3n;GECKyXUS
$ ^4 ^5Jl܌7҈o/KGegAjMAQgj]h/-}Kƾ%B{ Pђ2xS6xS;gYThI7J|M)]yWrgT0^MSo-4}OǾcӱUN1t|Fd|
v>;@mL"Vڸ6ҳKCQH1jZjBC1,-cز0,-cزb0^1q1ivA3
N3
20.PoFm%Qp7
^G=#a({R݋n[hƞb{.ƞb{.ƞ0>1
n)d+gc|6gco,vc;±؎plG8#vc;±؎plG8(eplg$UaZT֚plg;&6c;$plgdS;̕bܱ\ϐSU-4/*
gK#ӈ4";N#ӈ4";N#ӈ4";N#ӈ4";N#ӈ4";N#ӈ4";N#ӈ4";N#ӈ4-C^L~< GHùz[ެ{[OӀ4 <
OӀ4 <
OӀ4 <
OӀ4 <
Och%>'	xFɬU0Je^O(40laZO	xF9a˴g-:9O*
+QPOԟ5Uӹ%i5΂&,LMVՄl5![MVՄl5![MVՄl5![MVՄl5![MVՄl5![MVՄl5![MVՄl5![MVՄl5![MAlEEE_P~^+'Zll_/Nk'µډpDv"\;Nk'µډpDv"\;NEdֲ
v2RYUaZS3kSaZ_pd\k',(fX>!_.vOJ3s?R}IW^е{Q؝VP8{mXڐ6d
kCڐ6d
kCڐ6d
kCڐ6d
kCڐ6d
kCڐ6d
kCڐ6d
kCڐ6d
kCڐ6d-=(vb5?gD{?BW
l׍kFfkFfkFfkFfkFտ@+ő$kfV_30z|Ck!kfffak=%kf֋fa/V0g-akJ@3[PɟiU*+ʎ)Z@%fd@6;d@6;d@6;d@6;d@6;d@6;d@6;d@6;d@6;͎ 63D0c]ȧ%V41Mw@WWhڊlųZwclG8vlG8vlG8vlG8vlG8v]V
(I0Mcvik
8uaZ8X)g;t=k(lgn`J
8E1-d-ikGKpJS-jբ5#/Q@۵rEb{ZK
(.,]nۅv!]nۅv!]nۅv!]nۅv!]nۅv!]nۅv!]nۅv!]nۅv!]nۅv!]nĮK
_BѵjɢfRGHJ][m㬖c|Xx;NDx;NDx;NDx;NDx;NDx;hؒt*dXW0b;zX0e0s0w#v7ݍlw#v7ݍlw#v7ݍlw#v7ݍlw#v7ݍlw#v7ݍlw#v7ݍlw#v7ݍlw#v7ݍlw#v7ݍlw] Ìn\
|C6]E!VhJmeZ|;X!}>{½އpC!}>{½އpC!}>{½OˇV2IaZ[晬+0f;Xa>zzJa^pc0ucEU&0/a-F֢}nFW1Wxr@+E#]N?Uv~/^dE{^dE{^dE{^dE{^dE{^dE{^dE{^dE{^dE{^dE{^d
bTtj~fE'9EVnժo߃ =߃ =߃ =߃ =߃ =߃hhx=,
lU z=,
rXK\zX 4g=,
αŬU&aiZ=,
XA9kgWH	QMsg9OBgkN%v
m")g@vYw^
/sËbnx17^
/sËbnx17^
/sËbnx17^
/sËbnx17^
/sËbnx17^
/sË
ʍ*u|b5%D(mu]yfx4(6ڨhR[cZJ:lѼ=
F&Tqb8ѾMfUxCO#J![EQN-:&Uaڍ!}	,]L8b>FOjZOQ^JFZvڢ`2\NX)ͧ
=ik:^M^[koՈjD0fT-&0I(f'XO4 M;YK{=hh7	fH3QcFE;&Jd$'Lr*W?u+VE)vW/Z6hMY`#&\`nrjE?M٢Oiom1흵&Y@0/`hFWLᴌfZF052N72jGv/hK{P..]wio"RެG)TrIa:7w3}RfߍUNX`ب6g̔'B	<-آ@]6) 1}$֚ۇjõfY!x_X&qi9ђF&~_)`"ďy0cA	&	bAN]†w#lx@_^QFn
ILl̐jț!s<@1/~,<,Lxx2E9FfNY;`>|K,{F+!Oڌ``SSړ"}\ooO&зo&ҷgk-s<98f	mj38F287~3|l6ogǃod'Пd'Bݬ}Z`I'DŽOjOj_V?}YXaW	״'~rg7Pӟ`'0`@-Utݳ@,%tƢ}OQ4yf:|S~wx;SkoMo^kC)0)S Q(Q`)H}X		C"֏ED 9$C"y!H<ȐH$ŐocH$mW跆
8׾'x^{N}k"x^W	8ڏ 1&%@F4)a즘<
0I	%F!IRXkZe~Ā9.N=!/bmq)G ۟x RkogkkSp+1s&Q"q$scI}]-%D&	8TxA}A22,qQ@
AL$i-e?N/k8Fe%oN/k/^K;i{!
g)|ݣ`S~
`J
e+Y a[:knZiX't~~fOlSoq-x-؂D`,%զ7km*}KMCI'-OZ4DZDU&-Y&-E&-vpIؙvq~&_2]`/D;`
]`;ŰK>ðK>K%-Æ4hѳWWjj W
U*|ՠ	_5	!Qtt'q0(
PFx
OȊ8XB@Pj@,:on[B,NFﹶOOFx+h@#V4[9o@#mMoQ18fD??IVdT4t8e,@5A?ř@@M~@MP@@MP@?`&2PSԯ3PS/3PGm	ꇁ-GZYheqd͑VGZ8Bk=GZyYhm 졘79XFQk[^o!p~~B@Y $c0,nN[㟑?eA E63b%24vE-t%o/~mo_xk~Zko{j3l4'iiNlhNhNiNiNiNiΐi>-3	x?OPbډ$UQ@$@Om+;v2kv
v*C;
>C;~h?жn%^heRnyZ@^dȋ5"fyV@^dȋкL@^d& /2ӑqA[`٭Jp?@qOȬqijC,@!Z 8e,@-~w7qT,Ɩ޻Ɩ{hSM7SDQL'	 b
C(&Z:9sfw=9wt.νwW_&n>:C0ه2g>Hb#?f<H+0ČG:3`xC0us(R:KCdۉ?,1S?-0?#83?+8	r2R`6($E1l!0LC*!Mh`Hb0d02Y_1rgrRnM`ᆗ
,2Y`nxU`wXnxX=^#x SSt9RA!`$16o6l6i6fS6c#vx/ʷ;*Btnx=zco 	  
 FFFFF.F.F.r(]S[A̰bRIK &=b2
"&;' br"&&)|c3|&S"JэaO5')a>t'ᓡO&|1|/>1';'|^g%(;>J4?J4?|i~HÝH'O $@>Y4?|i~TatZxJ	@j~~f0%HMR?R.FUDUX-C1@6ƠacltFmtFWmtFltFi|V*r1,rg(5GumT!T!T!
T!T!T!T!	T!UHJBJEI*KM`,-2`,+ Ɯ r
b,/ 
+]u8;a8;}
ypp\U12b\ÀVuQ3`\#\;\.Wπ+Tw›P*yT<|@oyrozW--_%[Z<-[F<[zF
~_n@؊WVBፌ8PlclA1<6Ɛ`cltFmtFGmtFl<p,E0T*S{N!s!!!ҟCCCCWCWC>5u
қn1ݒ$Tڂʴ*H23ʬ*t	27ʼ *,0ʢ *o`AtXa	)i"h: :!NefY(h6 uJh ZDh	``wd:-Deҕ53D0^	͒fU¿
?$`]~X*uUQ=U^cU?
XW
?!`]~R!(=ޢl5Bqg?g(&;}4ecl1,6Pݷq]YݴO1,
]+GW;ڴ}!%5
/ [ ; i!\$
"@.RE
H tK(Yn)AnY	8H838v8	87 8.0 8.	8eujizu&@AP/dPgԳ@=APcP#yu=:`PԅB:A]VabuĠ.QGT2Ca%%%%%%%%~VޫW?xS:(Q,2X.ކW_Sm	_04	_0ֿXO}v*PDgcl1L6ac l趍JZ'0Og9"%:R)T#H:R%T#UH5:R-T#H
:RXGj֑2JrJ܊$
3L ?+s
"?/ /"( K/
",rTl44#A)dL#@1
dap@3
2
0
f1
&3
\B"@@1hi4P4P
b(S'ji\u"Q"6"62TamBX{tQJBXIBXIBXBXBXBXBXqFrFrFFF裌a\*QjUvaj8|eE*
5#!A06ƠNicma1`6 ccHla16nG
$%B`14CFv@Zv@Zv@Zv@Zv@Zv@	v@Z
v@Zv@v@쀴+i7`=
Jn%nUW	Wd&"+	p\ W"?A(rEQ+\Q W<AUN#=@L	84đ	8#qG6$&qGc%G.@&<L ݘ8
@mL LEL&b$&G3G)c8GQQgT(U
Yi
YqBE	
Yi
Y .2Q(d]dPȺdu)B!"SBE	L
Y!.2S(d]dPȺlu9{D5mIFu0Kdr
dIO$y'~$(eQ:Pdkc`m164ecl1,6P;ʴǣp㤃J2{N'H'ON >A:|t*4	.	3'HgO  >A:|t[E|EnMd%%;.N]r` ٥ .Av)
Kq]JRd ٥".Av
K
~tjG5dHP}SM&Ts9S%SM\\PMSMD|PL5Ùj
A5+j@5˙jA52Քjvb)c)`)LdՌe41Tjjj/uibjhvF'_H'rNOdNO@!AB:=tz"D&9\H'RH'rNOB:=#tz"G	DV	D
i\:6K}}D?@?L??~::2%H-o16@bkcXm162ecl1(6ÎDt>Jh>ގzQя:Y"n!BtN0:0]` @H@H@H@H!BB[CAn]ee'IQNr| 0GEA>*QIJ|T U2GUA>QMjoS=rSSfAN뙜mLN9 19傜fr9]rɩtS!t&"	LN ULN% ØJAN09br*9TrZT	rTrT
rTrT.׍GPT_BS}K"k"
ME.\.4T_
ȕBS}BS}"WME"ME~+4Vh/rT_z"#K7F-=ZVW+.%zu3V",⬛n9L!6
o16`flchm166fclM00vF.}PxbN&*Gdo	Bzgp,wYH[YHg!BzWpYHBpR?8i+8CpG,:J>s,SI0XNr`0`EA+2XIJVd U2`UA2XMjVdzR4lβttG!\)Y3tGLgMLgyAg2ήg:+]tV:tvY	l5Y)42Lg堳*@g2Ug:tV
:kg:-f:2ՁΦ1իnّ?mm
m<&Ķ5G!DžضFbyRmk)!ضFbyVmk9!ضF^bȋBl[#/	m,Ķ5ȫBl[#}%D*3@q=7աLqkŽG,?D{ o7a㍰|ncmA16ƐLhcmA1\6ّט_ˎB0Im]M=Ca!-q-m"_Kx}F+%ψ|hw=ˑ/_#÷w4#05h'hoggNnӾ̙9MtTFJ4i'.so;N!Z7-~HUu]Tg
f`~9ʑ
*U6dVSeB5^6l7HZBӐ&.4CP
{Rwރ>65B`!޼BSBs =?Il,ibBoO+om\o%oωn\wdo7iM۽<6YI[!}oQI?5O6jF5e+vŷ^/&E>sU"WʕJŪCvegj)7޴}]oD֛7ӑg3seyrL)@P] (.d9(Azt5$iYunҬ=;!>PoA ry|DQfcffg`)5x(
;)t	} xHj)tE{fSv o`ED۝J	D۝J	?!>񧝿])8]KI߽ĕWF⻘?T#eSGMUB6uTleS>jh8H](+Pgˊcթd^oE,,ͬͬͬͬÑ52?2?u2?!D3j.	uz	4g竡u
o^4sȏ
pD|
7
60MJDQE!
<Ә%Sy2(.Vgm}q[<~ӏ|G')p``b$bb4bb,"!#ZxYj,O''S2T/yUT:񃖼%Gyk5K^C5l
=Ԟ|zFsIloMKi:^Vi:^Vi:^V㵋
B@CA-O<	?Zsη*8G͐j]RcejL5ѪF֮RY:MU9~P*tJ:Gϯ_@]nW)TWlNSi4AZ9]j3i,AZ9;9VUji|AZ@j.?2_ח5Fo}{4 |(	9?%{Jms
61
111111ъXX~+1ftu%re^Ӧ9tikB}-ikBoЛ-)r=qJMoV*-bW<!Ůx-vCh+B]1/qętPf(A:88HթI W&_z/[>tB@Y4JMi1Ҵj,MkQu4m*i@3_
yzWU~"L'JԍQ~Rua;	WmRJsyy.p^i"p^i*p^iqs\iW>Ǖ^rJsosJssJxp]ZdD_2A4^^ߝGTs'
3bWn{ :{"B,G'#
65a	?%jO'ԡ%yEI^Q'(	}+JB缢$(	}n
}>	I6F4ZІт6<i
Omx-hhAV8'`&1eaA(L0$d	R@3,	UhL/GjgN]oQ;-VV9bzcjj5JL4 BZU,YdYYzG~"u+KԷ%J9rV}ȯ\nVW.WPʴlypsp@5Ak̃3֘g1Xc&<\8c;#3֘Xc)ݤ§AEnt/I-W/
>	э:9j/X"V%yiL͕KGyi NScV(.Vyi*K/URu.gt?\]V=Q~FڤgT_3jGZ>?}l6Obl$Ĵd\7|}_=dUr]=!JK~Zqj4O8q
Ti]3g"BX8q.<".B\簋_
'r*9,K8ӣpr\J`:{+R5X+*Tʡ)[b :{|S};2a2y:
J-_Ek(Ղz~zR@)(
w~9mpӆYI8-%HJ>

riv|NH>)ii#e
H2e8@{nQ2傛f,kc*g*d*Mb*5]pfR0]-PSʐruOPz?RݠӪV6j~ZڬKiQOïozOkPjSVi4Kk
m1/b^.
a-~[̵~[̫Wm1[PFo[a-~[m1'żAoy&a-Ͳ2dy{fĬ#na>bF|t$^O4:-N{e .E\+kW!Ft#Aq-:ƈklc|}622((!ʩ`żntBJ3Ayt[1٠<:ݭR+1Nw+4qOIgZęqf8Mg3|rFjwj8רbu5J+=Q2kTZ(f_Zkb5	t:	tZWWЮJV/Vuމ[uA=[zD~nzJԟt?QkM]y#I@0(;=EiG(Q,Jw{zbQQ,J=EbQףX(MŢtw
J=EbQzУX~Q,JyŢG(=Q,J(bQY\Tbu)~>Q3G{޿ُ8&>^g9`;w!FGl@lD܃qb~fG`|jQ#`|jpJE#)⎢t;aJGc9%HC*lgaAv95H>;%qIsF;g9`lg8cvm͑D
]"E`T.bwH	wH)86-VӘ;+-̝U̝sg:TUZu>[Pp}z%A=czonAzF-hR/6np-grF$n(nV_܂1ZZnXx|Jx-<3
c1'x|Ixqg\Y\$H p_҂K@zDd&/YIK@v8H@ θ@Mq#3"bZ.NdZ.ʹ\
:>iis9raWJN!ob5i0i0i0iĴ\R5kAWp[b~knKzDmiR3-sdn>2RඌR郸-Uއ2F}w綌-4kC/මz=2Nz2eE|KW	6Zoi-xla6*o+OxbVajLɺR(r#DG]ЩnЩnЩnЩՔЩЩЩ1J!%tjlӦۓ'4:MZ( 0%,0EbjpJ7CK#)
-)6t;8ҝВbjK.hI1qXΔ`L+VG- |pG>lU烋R|]-T>>.3~3Qxfz@˭qF'ܪ}-jWrF%ܪ1onX>[լ>קp\>[5N/U`nUxs_n=Uu^ƭD"uZ;"uZE:!HV(R5TӲE:aHV(R&i"uZHV(R%ie"uZ=f(rD:\QN+OE
D:BQNH*EJD:RQNL*E*D:J!T>dU0R&T%:*F*u'kG\nLҪӏCuJ5B#b0b"1a#!RitD",D"G 
EbD	Q(GT *UqzxSīsg:nbgTe=*X.䪌X䪌X"䪌X2䪌X*䪌XQz
rUFg,7QzSFg,;rS3h-pK*V*V-Ǝ;Rjl3!Xq^`Rc[(
*N;dJoS(N;-qt\̆H,5(G"fiA5,=(Fe$),+I|1N"_̜$),'I|1M"_R|gbVL@
ڡ\k;EδKPxy{*!@ޮ*w$I
$ZH~,&uv3Iye1A氘4B⦲4AƳčb1NS
|,Hի_ROg}Ջ1n~7Vmq]>W}oS_}6עM7Ar&t}6oէr&;}St>7U7C}V^U/m5u[1nQdj붆u[#D"{(nk^5Fd+m5u[^5Ndͥnk^5Qdۚ$mM붦u[SEi"{tnk^5Sdۚ%mu[KJ,));U֥+MqA|&IG<SN+%VTр!MQш1fhAL@LDLBLFLALELCLG@DBFA"\He5os/+d(ÊuSAWR
XAWSXARXASMCc441o&V!#(E{Xb>YCl
DvlrRYRYA/VTZRXNO[b9zmPrj$JXNB)U,VOqS2,w&AġqL
(fZPD1Ӄ+fFP|
YIz+fv$靯9Iz+fnwb'靯K(f3},rf@͵Ügjj֩JeSUŬSPsXj^NBGO`b:=u*݋u:Ttt	p\֩S#XFAGDŽ?6V|'tzY[ڬrK]~[:NC-営sK'-껹u[:E빥Su[:MKqKgf[:SOҧqKgUXE[{Eb^khkhk&k-mZ;Z.֮nVhkhkJø\[GWO_:@Z!k(k$k,k"k*k&k.kA\=%Tb-
m*6MO鬷Mʟ"{?AE|<='ߋʬEň%me]"vCсb9bo>}!GX8q`!C!GDoy29+2\p[գtbjJ*XR9.T	᭢b!Ut@Zo],0R=.E)᭢PjrV͔FHqWbg+݊WW>TRQ*VR[(Cz+)UBz+)UCz+S)Bz+)Cz+3)Yٔ9Fs7"e9-"AaY/˙AYe9+,g'/N$,&/yIr~\$,&/EQMr3{Y.q ˥Nkvצ:e鍲TX]#Kod^LJVRu,՛NzYXz@Y[vz6Q,!3Y@'X76p>U6yyap[V
yLm͓tHm鷸S0
yqB8yЏpgz}?ysgq6nlHsl}5U/ԗqXDEcDcEDN~x~~D~$~d~~T~4~t~K:C:Sߢ4\:[Z-o#o+o'o/o] o](o]$o],oRxk~~kxuxEÖr-zy@Գ!^sX'?W,G՗Hqo5_*Uף ED8q"$ɈS"NCB8qlj9s!G\qb/Bq	b
Re}
(Z"0_k}h<{MϩAj)- Ak~%PRԽAiԽE^C+Խi;~/AQ8 -"ڿOqxeVDE
f1{5cEjJKԏiڠԏA߫(C߫s(
}~̥;|JJ݅Nڟozgvڟn_$?'I}MRn_$ I}/LRn_$$	/u
eYM4YA(E;cuZGp-k=JV%1hpg6:8Vp`u	Gp0(8}Y]G:`X8pY]]8)ƱW|:ozǨOP#[?I}ads'a):bOՃ~~~џqgb[?SWrg3~_-yn}խQnBW=كɋgyc&3ɤLm5w+7X8	ēO#AANFlS1ç45b͔6§45b(@׈P@׈MٝDXFl
ݩ"7Lv8S7Fݺ}i`R#VO=FV8zJéSfQNz6]p*ԳéSSRO=[H^8zbJTg;QQz]JAwݝW]LfЈ
q1A'B|4!M K O )H )L )J )N )I )M )K )O xtp1U\L,PεNx=Rǣ]XmRUjlehuljQݲ]j\K_v\.ծdԞDov)xýR6+dj9{x]Lى=Dxy	&`O0f"{)z5/<>5MS{rkh;G3mrf,ch.0ZGst1{ԪhaTqi(ד=H-ܣEz-ֻGK>N 
>h>V=ZO֯qv&J>a}&~\NK;Ww:tX߈%~VNkw:hHNG4,~#5tD-;Ѩ(epiw:tD鈦tD鈦鈦鈦ffff:w:9w:w:yw:!K!JjVB?:N$'4fQ-ѝu֧!>G||B|b;"#"a!;"# RC6b"HGd 2YlA"5+. `w̬.FbހjQ/:tMa`ކjk
GQ3H.P#]SL0CtM8J55->jk
'Rjk
'Sf)JcFp:"o0wLs;36F
/F]I-ءuq6abVJ[`byޅQP+PC1JŨmabe>twNcwJR-qc*eݎXorVǷJA[$[$[$[$[$[$[$[$[$[$[$[$[IXj}T2Uuv
fpmS=)M!uۍFw{sۍѰ(e1ꊐd5ۍfn0Pgu2ۍ0PDzh:nLڇ$nLZvc
Safݘ5tur[tL6N;ouqmvo؋6WWpc	me-ܷz1H1pEF#m٨;[-ՇܷeHcmgiܷv6.l%mW}iDLUWTLUWLLUW\LUWBLUWRLUWJLUWZLUWFLUWVLUWNLUW^LUWALUW4&+(+$+:\LUWtH1U]QbTuELjҶL.5ꊺbTuENjꊶNS(+:ILUWt1U]ѩbTuES)+:KLUWt1U]V1U]ѹbtG-6:*ѪF&}Fx2ZUMGMMndf8j:Ӹﺷ!ZOS(C#**D5QC#1D#	1111
111ьp-	IɈ)iYو9V\<|KZR(}'-K{V;)ڦ4F3hR"0l.sT"7@3!(yu3Ԭx,[uڥu`@;Vu:n:7^wF]RnQnx݃Rz6^Խގ׽-uOuxuZ_WuRWuR7R׍zfn-;vx
;F;NΑox6:@]uԍu][1@1ԝ9@%]7@=2@Խ=@Gmun\.\-F
f۷G|L)t̓1Co+c3K댻G獷mP~.4.z0# {xar7=qߦUizBZCkN=TB]u#4LOS^hG#Q.Pj
7U%Ej\L֨KAݨM'k:Wat=iti55-#WyMjYӵ.tm5(Mh"K֩Z6(zTիԟԋZ^Q]VS+B
zXekG\tѺN+qZ	JZMuSCZW*}>ISdjP-85^OTj.LZ@kvW{h~ôZP$uV1WJukV]Tz3@88A''+=Luj|@u=Twm\iUT8hܤ[[~Ꞧ{{ɸ_y5JHu/QKxSU룺w7}ߠ7S3m|aѾMu.
uYJ?SW]K}{JѿK
PF(STW*ѡPTCM:4"4R!#
ˈ*MjAL#Kz+1JQnT(}#DuMpm4F)}+FuژjLR:[`,bcnathc/cR}Twq67V-PK0+PKnLargonaut/JsonBigDecimal$.classUkOQ=,[Z<-Gi Uo˵,nwQ_H$1~3#s+ Mt̙3__snnMF4i*`t)uʆDr1[-FLcb
(p{?yJ{RnFFX׵<C?
)3զ*hd"[BVXcN::e6tX|qy!P>PmflK3xWxRF>YJMhcZ!EdCT\zY0ty(Bo\h;c3&N0rCEy(1vĢ/`K?utscZ%"̹j#oxt')1T}%fFMTj|n3Rـ6a4Jh9gL&83IzPK$PKnLargonaut/Context.classTSVM!'S)Xvb@R{ٛk@"ztv?~1ogv`!LADZ횿2 i/!ơ,rQ.$($!;7o2)q$
Lg\Ċxk~zM=bH4\+F޼cOݓ
O@.sϭ!}&>y0t-rl
d94SAK"=\矤+y9d356_z-s0LM9xtJQQSZ=0u
6h!:I#3H/#kH]5,7hǾ!CN$|
|N1E
:I8[4{i/XGF9	9TF0FJIs<V2Fw8)%PK[C96PKnL+argonaut/JsonParser$JsonObjectBuilder.classWiS=oY$Brdka@ Ȁ-Q $VtfQ%qguȢ+*q$UI8=3%FU82U;u3!cV({\LgdT1m̜!жf\5,^r'5I2fsN(EavW4g҆~XL

lo1Tl!*@
_NV*ȖEL{%ˢjڱ2łqxeWqOcc۞ri{elXtd11Ah{7SSʳ[:npH8~\Z:?	޾iьFO TXM+Ց30{w߷oA @ӏEdH/$*|հv(K>F9wf"i;] G;j%}:v#EX*#>!m ʙkhb|,I+,޾
ALLs3O=3=cYWLjcIRuBp"ʉ'~͕uh+φiNKͧ+̻v`I)'g-t|	Y^޵5
cuԳ'Q*41.F6k1_	oBq8
LZG)]rg~˼~I)]e
W{zuzxYi>K&KО'̌i3&|8-K)s}XY>T~r=if3]sE/g?]2a,9N.+ϓ3QXp4
뇎+HFBNu<%^^`&As4M?+'>{s40}
7y|(\˚j
gk,Or)sN14Ҳ	6s-#7YI\^	V<?y`@+m;S>OC|Dy]!D'QOԅV$ uoe+Գ"G
Rgr?D-䛾kO;x/J~Q=8s"{O<&bxzna6pp!wQy}j<jBuK}8LGcmTXޏJ,ר(ML70qOnLE	6>$6Idx8(Aw<"l?/9h4\G1YE TwwKZ9ݢi.bzf)?'5rޒm	I/
G<#T`f^M,{Kߕ+X_mH0ܟI&ch-\v݊)gdEE4"9+6֙.c%
ot482+>
ҳ8$p_f.c
V r*d__#]gBa5x(?B6:Ml
ux
/в]xiGePш;Q]5%-|gZh`~*D^!RyiX!V?B]j)-PAp8mѰV=U''ĖlЮ
RoKrɄ$f̕2;`oxyٻegth=L#xmG6v=X¯D#~zL&&A#d$XubVZ5.xTTeuDUg:TPjK?PKvAA:PKnL%argonaut/CursorOpDeleteGoParent.classWVǟ ҡ
BE)u
Q)֕z.! HB'^^Bu-kI|?ϯ{?؆KxT{x'@Sg##rN}rOwB0p{Y-7F0gyw.A7`Kb v_Up g0!JLY@KY(gZ}\v+T7=v|ݯUx&_#1%hZKkKȹt'zV	f1e<CXn-wOw,:VxlSK]i6)~mM
N\)m)U\{HuOñ%$!<+Ps'IJ|;(*vmx#z(2H֋z^0;CKBŇb pT蠟A[b[(©vhif<P!w(ƫ7[Rv7.H9ðG9pl#vZW/K<+a18(S=۝~WCJ|-ʊE+>$5e"7Ǽw1r>hmͫ@>F?
IeCN=W[st({'Vleb/1gW4\t_/'(JMx&
[ZJ?Ͷi%")y8 \C7xX`\.ƓRZXkIꍌxgHsDjwA{3+rIr3\LͰuyuu D3cCQQ{	K&5!d."}gH} .aE({"f+c%(FIE34[6GnqjEV84Ŀ\sjk:ISJ?I'жMm3m=SK|)")ygAD`W4&4Pq-'-7kț:]4M%wI!Z?Q'_!UU|tH@eӕ|hJ#c#
Id)qyܒg/4:~051@D4y>‚I$7CßG[2ӕMAd(u#,eȄW&t$U`Ê9xl	lOv-`oo't<d-@['P0!`"
pnPKWÔPKnL!argonaut/CursorOpSetRights$.classU[OAE.b[*T rr	Uoe,f;Kw	$LQ3VZ=s;Ι__Ss+ez*7_hd%n1|U
iwU鉕xANAZ3׶EJ[/-9"+NVxyYܶ>(&4zhc8g% z35قm9chI$ڲkFqn^zSdM$s|mU/ta!,׬
C+/ff$d`a4C/,FpƓhD1
6`8Vιgd0qeP"nZ$"krjb
N6zDO1VF]p5+KW?.-1̀A~.a&dK(
wj/%"%ojA U$\H)r64R2545;ҌL*<;[5?4*lt`1C2})hA3gxPKHBPKnL$argonaut/CursorOpDeleteGoFirst.classwVǟ@(-Rhuâ!-V[[wRLiz$8'g/|GS\I|?Ϗ{䯿[UH#MWܓ
M7\,\IoTOtS{WrXinO#wD"6&/)M66Jw #M#`dž#Jsl#
S!z|޹8^2v-tODq$GBFN@'(Q#}ɿ^I./Fq.˯<>E3;ýܵ\_A=s_f
\3r{01/Q	GF{Vn:\^+6=sgYC^;u	&)W\A>keֈmt7wBnxQ8vKNJdx>~tN	9+3zcn4ZS#o+jj9:I݉ERAQFC{PE3_dP§xlųҐ(v
Wj\-_kJ(x:3	GEraVyدb7Qr1$5BsNjFHo3[9t\خOtl08,޼c9EMx^`9DLgY( O(ѹ@{wֈPۆkƧζ=o{"b.Cj1|<^a`ayH!~)odZBH4/8!.binMe	u!kjdu vԞ9:H2)Qw:fj˴,|鲂bYY"N}2;zHE@^d',܃u 6А/ZQn-OdYWh>&9YxhiCt,,'i_ȆcE?fe8ݪIL%>l*۴eY
$ᭆXhƥE>
dU::rYP+=YTC2DnMvW-\@7BwXlWoSt+hA47}e'7CŸGmkJԥpQc3jkʄJү_66l6p
@
gOm:@chhO9G']:ДPKZPKnL'argonaut/EncodeJsonNumber$$anon$2.classuSn@=qIBxK*RM$]vH7J !(ı4!9{fOϰ-)r_9To]R]~jAhYvT/j"wD݆@qBF`m!A'})XĽK]_
w3*w2*Rʷ0`naS!}z?	8MU0TD=7S$<,,~izLo{0~vkΰӮXM p!!`X#Ƙ9}WkP:ŝY9kX?O2Ƭuzgv茒ciܤ+J/JM[c/(
t|`dU_PKPKnLargonaut/CursorOpFirst.class}mWfǯA1/*xgNFitH?(/K)c/Ӌf!BO^Pӱ^$/-]ʪypN FZ/ۯ߮ijS[>Et^E^Qy6[%O	w*
PShL=,g}h%yFMeh..bJ0e#p+҆STvPP޹-_P;R-w2']jmry>Rp#2NꇉZnjMܬxE&|E
?sI&Nh.%gL˿r))4f$ɣǂɷkuᶻB\!6oCg3DuN\4tJ9x >L'A?~&,Ɣ+z#?fs<zSrgKq)Q	eNjt{J&N&6β-
*Uzp=8oj-SW]ѥem+>	FF0#pe0!GƹuRB#R[o]9AKOV9{L\<pr tkA۬. IOY[YL9G&5% iL}LJJZ~\Rر
iX'G[hDFU)T1<$ )gŠZ$0Y*46K>U#W('V:$IBɖeM[|Xxf^հkmSjkٶmm\Cݶخܒm#)!KRN|<"߫=%]Z@o+jizzS~_3e+
Iw>d<`"do	!	~=0	d[ID'&E L`chsvrah,Q߾vqqѥˬ%;e'Š.l"EW÷Y
ښȉu[[7ޛ3ԜtB;%Pɓ'SG҇]dEtW.:~ӝ4(HFvuܼ7\4[B不QBo]p'3L&NDDcN3%;zx
	I,9^L
!\!|'mU׮DhPh8Gx?%f]FrT+f[hsbٱ]X!;N-7ޙG}UA/PK8
/PKnLargonaut/JsonLong$.classU]OA=])TDEmAAD-$_eelwW;
mt9sﶿ	6zS%Tj˜-q
MZrM̏|Ã/h-z	tiB
oZhH;S7aIPKh/9~PKnLargonaut/CursorOpField.classW[SH>R[!cqXC&@ $80yLe~H~V!lTej;lHIe}ss__tCWkHV|A+	@t_ۛ+j'n
踲xW*e{2RZٰ6
j*Z˽4*G]$I8)grD`:Z
W(YI`2w *7LhJ&Iqlx-/i3qwL_)`"Ц@w7ajPOA	%rgYdH	fFF\Jp.&h#^X<&t|i[Ie~OD6<.J^B*.^!(ANߜ`$MAa;y+7QK
Eǟ)Ƚit&kb+9YIŌL|3^JvħVTRccD?P*Js7'H>Yz~'S.9YzzFŲMv}xMs~d%Eg˪ؑ;.3Ӵ].1_Xu;C[/~Xӛ8z%AzVӄ/(ߟR?$XZ}|q'}_S}wi
{'[>RSG~0aV
vR%M-vZZ,:ot5	ЌzWf/υ?6dZ'AHcs^E	:RЍU}oP	5=oqr9X^獓Q$Y_@`:	D@<,TJz*sFmI0a"l!B{ھZ+eڊ*^-o>ۢp#9"J`]n0F΢sX,{;»[;i}O;]kIUN]L]5,h#ITM|FZ7e:4S4֫4ꡒ@Eҗ0u)	8>MT)cO# HK
O,k;YSnp"bkͪ/`JԷlX3
9Rȃwv4u:ܺ#hI<k=bS7T}4 `QMY g-R+5W6rAVk'9x7L5TДgèU|R_B]7L҂QoGZ/"o`-}BOjdnRWppoOptچA[GG82a 06>p|
ؠ??YiFp@lzk˞S/mQǟ^s2QN=D.t7̊$#4~spsU(:
ct؁R+Hy8P7cg:p'[^/0'y0׷6HE#0w%R>~VX8};t@!2zQhwj
H	߰:zŊE"u*C'lX1qR&͉Č3#$sSCن2Jl!٨CbeDzl}anBvg>Nv)ۧN=VDPK^	PKnLargonaut/JsonObjects.classENMK@4IS[t  ؓ4DQXCZAlēM܄&??Jܶofޛ>C^&Mҹt"+J`#`vd%E^9HV,⺭~h <8$D=cδoY1#|6Kvz1t<[OOtKč,h*-Q62-S\Jd*+_V@6t6mk97l_PKb MPKnL argonaut/CursorOpSetLefts$.classU[OA-E*h-U*Z%5V1>mD}%D㛉?xf;\JKl{vϜwsf&(W<27u/BZbYSG^+M/֥+r.p+x#BWήV,X)=7_[{T
mLT[
0J3눪pX`̗fS콅c,2t3=5~cH,}]a8Xo9]5h CTun^9Nz3mc`F0p!1Ù$f63TS0]
C_s~k's&΂z]ҙFZiHjNi
fcK
]_z&Ꭓ&b&MÅhu1DƷ'\0joh[
ht[*#Ng ÀeIP]e{2q^Zx!M-=>
)|:e+oyMx)OPH^WĜ*PV\:⑻щ=']AMH_NlMoCdDd_—HLVt
}&AB;t{tvҊzlW
H64z	ڼn=MO@7-)R'`~O8!TTIXSPH챁+:)oӂDbYh"iRdDf:nSM45k!NhF&^/M4*lh{1G,k(hǩLD39+0>	jJu 3_$%k<dDx{Oj&91gf."$z@W)pe&GŲY @,4O3cM1OzX~="g˹)%~Nv8/oDٵ#bZChc&=i'
樅e9/OyYHw3ҨqhcX&18[%}՗!tzã|wXxrm^+Y/Qrby[bĒik5QA49{TMq`dN+y_L;}~h3M/4u`WY0DQ4FJ^DŽȕx6|cu8	O&7O28^'0_"#`b\|M`l,޾-dK}{D`r	:Qobgu?#Go
v+tՂ_Xxc1}A$ʹ	55؄~;nųJT%+<Ǭ
E>8"1\2oA:t.֊/ihSSl劒eXzK+1P|`W<}dAֆP)hmx6hު\IPJ?h5Y-@D̡rdUK<>VP,@zN띚sQjrv1VP&YUZAGX]2ԮZ`pw@`@W*UDUAc7Uڡp71! z?BOqRy+ɛm,~
C҂RHMV׮jbFH'"mQ%'?m[PE%3i8SL,_K
g`n⅑؝Y!Y͟nIsj=׶A^tzX0%n!
6ZiY?DRdt'$B=+bIBqKa!fB𞀪T6A\΋

)J{F K۵RF4Fl
ٗ	?Wײ*Yi)p9vPP ˊlw'&EL>W0Ooc6Zȵ
_4׋[gW‡lF3[G]Ї7B.]}BBW
i<քjBok}a*>F}dߣM2-#P0񶩠>P}iLT}<֥6A
TCϼmۊ6N6D)CQcxࡊilK?`y߀GX>v;1ݒ5$k!Kw??e7=ً,Aӻ,Rϑ6hjuKH*ӄ q#;lFQMn?
;|v~o{[f[|>GM-aeb{
]̆7h[OA0wz߁M}K$7lG"0
+	(&쮐Ʊ_5KW
~-οo=cK,M\OoG|2JO;/2UkX!Ӛe=ac=z7OշFx1!PK?ޑPKnLargonaut/CObject$.classVmSU~naIiSh ZQBHyQTEi$Evt2_[i:2'gQN]a̹sO߿`Mkm}aD0R!kr޴uKm*z2况b
K5bL6ۆY(r^ݼkp&rm0]U)ER2U}Gcxrk?uM)08'fPPU1fw`j-0ә-(!).eI1\Kg kOm3DVKa5v>L/"CDn_O.5T1\kr1=&\2xKJ-K.wj% !LiL2ļ0T)*?4U<	$!ax3Nkg%PiozU>!uj,:C2]7'Ys>$Ƚ~A5Lg0;}8nubcǮ+q/V~?_4T0Sw6(4(bQJk|,_f2ꕞQnbcZ~Kԧ"jݍ7+ⱄHG1`5*²pdb4|KͺbzhEe6]zw$kِMXI-^5E_6ʊ[6Vuʪ&i`J
.(Ymi8uzc:y+_BVecqhsRΎFnw_zFi94n?bއLql=.Y )&H%A	J/&S?=B>F~;
DFv'Gj=
u
kf6{*Da$(yN{
GXEUX$T$u6\r2{GS;w	'&OcNbOIev5^MN8G-"j7ozHMz/2W>_	Ēy5?\dk_>UԙEr)Zu;̐oQF!vGkz5{%dHr?g1daE}4_ȿ~w	i4)4$0CV{-mzlLAiJ'\i"*VZ9b*+mX'p=Nm̗ma)a%!;M(/ho19㺲]ݵ94D[87hfH}EUYzY"Wz1-n=[tҕޢMu璫͍obzob.I٬4ib9	zk]džGf[Ō~PK\9{;PKnLargonaut/CursorOpRightN$.classUkS@=[
!1(- R"3m[l7tàȯ>fđ:rgڙMn{Ϲw_pܫ*9{
+ʪ1JFWyrj"9]j(՜/qe*[}襫0NVtH&9Z'ħtu$-E魓!kn!|zgv/B}7y/3Z;DR1p456g\-\]ovvp>dI"V<
|.ZLZD?A1bN1"MΣc+Mf#TԳӾaE&~O2Q4ف\`';L5]:h^ḧ;4a^PKYP
APKnL!argonaut/DecodeJson$$anon$1.classY{xme;vhAB$ĉsi)XK+gZhӖ
=(-/('m)mJJvv7{{6y?p
Ы9zHhG0ڒ6ljzIe'2HV(h#]Ŭfj
S%h;䌘_a[2*:gSa=ahVԋ>U*(P.U͓gXsO$h&9*ĠQC1cF1mX0,L2\"aV(ɪWAܬKKX,+7&å2VAV DIړihO{؉=
x+6dED(pIյF\#U0':Y6dOfs+6FiJ=JY#C{o'hGEprU)uZJ+Ɉ#S1>"RFNsrS70ZY$G@jT7pn(5&w!97csMSLhCF >FWśq+x79Ő*h:̲})#U{f*1\b4X&4S"T8y$+8vmOWd(p&o%et*T&׸-bHCb8MJ6R[:=uV6`Rgx5)cJvzmq>Q嵬k;
MJ3UcI¹>~kuSiNfޏxl{phg%+yiA4>S}Sx>D>܅j~&ۋ׬TOk#e&O0h+dS/P7ӵdʓ#򎊭7UF/ߡ_P,2r_U|t
p'›9+ㄔKNBK'T4*(
Y]kKEז@)]w
r]$c*1|U2Me=D	".2|U~R=E)Oediy1xsNj=US{*YW&?Q:/=K6ӵc	Exg..B|eG>F4Fc_b4oَӳfb}6lU?Ix4Hi8q}%N3Q_sD^,RT2UPK
6gPKnLargonaut/CursorOpDownN$.classUkS@=[
!1(" T|C+&X07я5S4Zմ-lbiiЙXyp_[ϸ\G7^	BUO4牳= V,ڐ|iӰVЀҥ+iȞIez%~B?tZYL+5|GtYZIYR[QD.^niQǴҙH0\0)jd'ϸ{ߜoDDpYR$!#6>O}Rpw--Ÿ1wRp]$F@P7<#b$:w#H}:QޠGgҾmGŴ)hj1#L
UUPKN?PKnL)argonaut/internal/Macros$$anonfun$2.classV[WWN.X.EPc6\ד0L]>t>G~g2Vsg}{=͟	Ct*%^ΰ<ݱ[eviiNJ ~^qҔ9nyFUJȲ!ϐ杺Uۚ9TwLd%t
Yӧ(c{HuP;c$K>-pp4DN%l J^j3-h\ɔ%{77oܮ^Mߔ7POtnqjN"@c
5CpoU#rA5+;v?XZ~r:/pCV3֝E2}jq@>dΔV%^z›4ڽ!m;nzIBpTXe<#V6iM[pA¼q9K>UUC%#,.M麪dxY\h-Q_)h:	@O4ܤ)]<
gq'\WtO?ӆ$0f`Q)㭗=Ib	t32ВG
hh8BsXx
]Q	7@4,
wA1,}@2Us[O;Ib-½6׮'\$1ae@׌aެX.VuQ0س~mIgUQ4%7ؗ7ԯz;٢GcEbIp=SOuDN@l'HQsy~J0/,Rhם~^ʦVWdY@Eb2	nڱY9Q08
3ѧZQ g]S0r+HEQSTtJkts_KE֞9Wp'/i.9^i|~^y,1$5D/Pf(g)(o0M<nC]/44'}%)c!顃"eU@!}s׎h">!%HZ2ccѿ/_5a .V7|C%o>^66rof(gUd.N~UKǝZmϮf4!kЅB@	I%Iz7\kc=&bQHe&f16M~8q&ߐw靦{>rPth5ٷyKq].٘).MoH1Ko2KN̮mVOKֽ'O	ܰMKME9meY;r]Qiܧu$H[[[;Ev l<2*f4PK'k5PKnLargonaut/ParseWrap.classX[SzD<aG$.`@ȬG&$a[v1A]ͦ*o_KR3
B5=ݧӧϡobԡNZ	TJe5[R.cʑ{oۈ#zC8yFKQJ.dZYNRt|d2Y0%TH(X8nNucn
eR2LJEe'=$.!Jܫ9D)m\9_g[^v
rI12,cK£"'}JRnPOL!)පZ{9DYkvʢ .1ZMTDe-
x
=rYc1ÊSv1y>'e@$.cGͿK*~/GDE\n/U>Ɯzddmi(;)5%f{9M팎+%LHI+F6ik'3ۍeOoB=0gv}+8P2Y5:7*
9pHt{}%qbw$8)o>1C\q|8K"!ԥLa|d(~>I$HXj'ɉ;DLVSa*nYDD.eS6,4s6lwg+IIɞje8ё,`	z1lNe){~0&$\kѠ`!ّV
nPqz8c-syRYNI!tG'*sI|A.ZeQbYAQMrJ^؉OZȌ)L.$,9}bhw$z~8;TxLVƀs[!",^Cȹxkh[ȫ⣐Mg6.!2$h=SxB$iK8t)KIzF0S?M^(^RȄ˔E,1 (kO&ҀA0H0\#hVt>V
J:UןstKw?A
te̎F)?xf׺VFU!Ǡ"}TΪ*Tfu.:W2œPV,XY,UީErvp N?WeE]ojzdG#KVƨ3u3n02MUB[fZ뉢Aqh	{w>$0o-HÂVO5MU90չos {
T`SȁѤbXc]66 ,60cWBEު.B:ba8Bu!vc %:M6at0F{9zv;4?n9d+j7Oc-u[kҐ"aƁVkD_dWnczViDZu
[Ҵ
Zeyd0{
l7PT<(?q#Au@jO)iљʘ
fH-#
dvNX&5]tV Eoه巅nArxYMwcprV_}*ڀ%(7KM-9&S8SwnLZ*KZR,}K5[19zЄm;-nX\[e^5sLg&zphzsmX-UMOޭj{ZY+
ŊSL2~K 7'
'EW?!	&!TF3
wF M"
Cmr	!{oGm^hS1|~D
m=6>	
Z=͛25>i61Tt-' =a4rduȱ Mېh>qS;B!Ӏ8ZW݀Oh6MP=׊æb`
x0Tԣ}IZpfj"uwOn`lދo"4,,Dx",#dt`]'|:ŊI;33X`dpv`%dU)#v^༑A
 coFLUm;n&F
cx^0I
glG@'z9$k9ݐ
}zqlꄇ]JGexT4NF8FL)1Fn3r*
PK<
&PKnLargonaut/ObjectContext$.classUkOA=S
ˮ[)o	X@߶VEJiZX,vK?WM$1~3Gn%ffv9s	&vl^R]QｘPUSn=+T<],Ǟv>O{eos+]=Φp-^>BI.QCH>3h˫Obɲ-/O3tdDΒ1YS#a{;V˥j%meha!v2	*#crǏcZuCmcg|c+SΒ6㪎1AU=f咠D$>O441)6p^fK1c Yg|0t|q5ܥ]7D)ƞ	eNa{:&(hc15̑Gt0om@)Csit^Ive^A%,g%wKm{n=omܫmɿ6YR#坪[⚗K6]qdo9t3@;iz&YhKhEm;L*]zz?sM߄>FLL“<0m$'ja ȧA\R5eGѬ%J/d( r
:
+Hn$ct
7jY1G1;ZqY)2hE{Uhg}_QpF9(h8I%"_x<OcQ!♂=!{8F|#ਏװ8
4[3dކj+Z_CBZgUTɮQaXdPK|0lPKnLargonaut/Cursor.class<`W٦U+duYV$Yőkd[qJ^[ڵK*=SJ@\9 4spH8Qr88Hp|vג8?_3_}g`!GDST|=Th#"C	SCtd|x,~jwd2EPEl`Cpimddd5ј#g)(7	QݵrgMye@kc_*dkel@)_imPɕ#yzdSڮ@l1sO{l&pTmm.;<4PٯZ"*޲6{W"Y%٩bvK9F=fTDn۔TtӴ/Br\a*
o(%,,;aY2ׄ-؁ݖ
Sn<oCn;,ѿ?$%x.$+XUȁ^,*ͻA8+;1a\w-ћ$7=06ePɶ@
	)KDSƨ{SxTmW{KR{?z	iG:2]#w6B[*}0UZK֟X[ÿ́ݧ@_&nkMh>yB"}݁@ɴfP%FtK867[pwN	/ũUb/oC\5ǺWm,0
VR@eW즵wB4;Xfӱ7gh:yޖ|'"۵vdO>%VlJiL$XҚc?^X8,7uTiÑmS
hG^MDk}He`Ͷx*ހVuBFl2uZk͡3~֒9{gXvUJsǻJWZ?KQ(XfY%|@$[]n*fMޢ;k|&lq_¶ëNv?6d{(4ұ~e~=mRQ khk,vs]÷h$|OK_NzGFNyE?"´_VLԯ"cx㌉"Tl)MJ֏t:'D
y(L.sǭ.0Gw "v-[#CqC+4Ow6jT}﷫h:&~2l]ֹɷ16,R%ߤÅRR0OK8p
*%o*2o !O1m7X÷[>Z.Kn;PV9V'H{P{INBNRS;KlWX'Y>=V4+MwMaKm	I#S;~{],	zb(˳'yq|~փr"rmw`o%}00v7v)f\%rU"F_I%K=Tݾ\3'ʦbZ@AV,Uiv:rl:r5qkZnwl*j)rI8nU
EGmӞ=-Q⋯P_:2޽TxP-ҽ~[Ӂ	f6ӷQR|6l/HL[֨1柄UMM,kK5t1>}\"Ѭ(8hAp{-oį"Wˇea͇AFq_@VuaɲeBЉITw#jHx
bxצ)O\5:$çgّp\BXNރ-Ѳ
,Y%㋜-R5jyI4wx[vOHtjMȊ6quN[l
U)&ڵ
]
E=6pSpS X'NA(1Sƚ7C5%NJ`
B>aeگf&a(Bk6r
4h@'IY{єCOEag4=auDb]E/)uH%vict{Μl<:ԱD7i<ɱgTct,H6+=>u~E%o_65KS'Ӧ`dNuEFSܗD
':ʾx,B45o-mLR<|dt(fFƆwG.݊? MI?v@T`p5sy}uV
\0Oi߉?ZcB*SlNm\_K|HrX:)ƽ:p_o%040E$tMp#=ɭX:pIᬑiCǬ3ZG-WCq8Q](Svt%ƂPdB9ee++ڬR>bE?X"EɩACwV/ܯe0&E,I-ԧ1];GUweX(ts
,#AZa!;o֮\ԚVLZ.(ytƕX=j&Li@]X5
p]JkLdzPce	aˑp/zEyX,jCaP$H7im0	͘C3}@|Nv2-9V*"=*!T';`nfdLM'\+*<
>qaƕ]l>?QsfM !|11-BX8B"
 ƨ&."zR\)fr-pTlƼ{2n3ǶgYdfhqƉ;dk:\ZpΉI?XpJY#83ťO9O.1YƽVjP}`$BhvmpaW3V|1…Ӛ+yFi`4߹O;L{<߽J&:^6~wߘjs<5q5u?!Fzׄ]I}xEd[uV.|F3-̜1uR+^ІF-xAZY5y?AUօhdM>,

?t'yLJ:iJ#*wr[aSnM#,K
8q)OE$AgWAϒ:hh_Z8wd:MVK"-2l"d^}	[Nغbc
]b@*5>YNI[i=ƝL9dp
7(gty /Qc.W)v6:ޢ9߉jfԄ`	fiZ(;}~$P{~\@Xߴ	jM+dʱJf=?3dX^0cvJ6Zu1FoDZg$?\v5
LWS}.)_*pU*Xe82hiXWg?{"Zl)6cTi6HjIU#52+fAC#
X#B>bWXT%eʊ,k22nu	XZiS+Ȱ"G\HU$ANB%%c묵u9hZmNbkuӭO	Wp6	OѭkxqhS,H@|EaG{ʆFڹ$S1r<ͬ9	Fq\GЄdweTl..Α:Ys	Zn9|&d}Yq?CJN\]Ow~N'$HYa62avI	~'3t9>F<^xY#ua+A7Ӑ)2iQ(*rMn%#4KXORhʴ^(ӳ =yа9Z6Bq京)cBY9gmE,4t
f*ކs?p?- o:גaklԲ89ql'xMpCg$S_tPNBξCHL! r,{m PY
*=ԢŞ%}ŐAxɏp~|?ܛW5;Ix`՟XN|j9\lbNrEffB(lֳ wX8>Yq,,Vŭ;#<ɃWw1\U@#( 
+1&m~p (4H
jdC\
ʨaTQ0<
.~|@(B+bc7A{:IUdp5BgNŪ{A~GF떟|#Dz	ّ aߎH~H~1_,BC~?%ȹTŤ/t(?,-!Zdx'yY]|*&""|zʛƧvzUW9˄Ts'CQT,$LJ
Iː_oH!)pBL?NaJH`s5I&D	{h6U$k~
'W|RᇯAw!K	KHw	2ųX@Ȇ˱b^vYp9nC!~2b{U[*wm1dwkA$e@W?$Oі`vB")K!]A:5̲uAN5MqbklK0;2fSv7/dzdnA{C!<!>}[R0C$Mڽ!}=7}}RAMݒԚ}$hI؍*>ҷUp	4NszڥD.#]knܪ9^)Z
l8ZufyAʭ)Q+oO}
	ߤE7lN
'՜(M[0qj4-Ezn_~}EqLdT1?cdfXmWk>1/IE[2k?N4^jKO"+[_-nj/'nC>L+`}E|bgL!ޑU..RuA);@l	pZ="K5Y*f#7rcPy|xg8
yYDd|{9x;
T	Q0b.fB9"t
PI]5{`ȫxm8srKP<Nfܹd7:Ϣ,+A)R(ct?9ph烯:8MA~%O1UYiyZ_ߎc1a}K} ~]#(1#r
3b
~#B6yx`Y͉v{		*職a^4.<즳#Xǰ'^*_
~"b,X,@<<ᚾˮ,Zr:9QT'|$of=AB"M!-~=,7R4~JR*KB;1
x]YFfc"ONkpܼ8*71HOP$auIjx3V0eCLClHVNȦ4YJ6)	
$3Jߞ!I4$V$II
I0ARII}a }!([ρW{zAQxT1/*k9PE@=6nD
="](O5)P}SӺ<
FDx1drCf2{4CfIfiCn:#^lӝ?ХaȍIsk4/Ex:EȫDJY<Š0L"l'H$Na;p+0 nj\SUL檺sṴjI*%}BbaWzjO\S89oht9%uX{LOWa7Zz܅}0݂{zd>g,ʿHbaoOnFX7]h7hބ*jjqm)ƻTLcnbXAlf[q0|)3Pd-ndi{2mX6eDmD Qv;Qvh	}> x玤jpQJq!us{k:EPb8:0եs!1
ccDPYTn24'~k/.f-wΣI[2Ig\'Oqyh]7_JjBQ#nj\ק\f.i)/9R2_=eI)3I(SK}GoW<WˋJGz
>0ԉT>AVũ\
^DL!#~D{EҬgD	5)ؓ!׾V[:7ask[:%KPrTJ:.URJ1.
^GtEZi:.u5%" ,G+]P8)fJ5"R)0ipSw6]0w*x%{a_ߢbǗN*]8w1#+%WI%jia|t'VzG>o49Yzb'*\eGqɩe=Bɸ=RuEnYW
ǚP3\A&h]CD'KJ89R΍qw8{8#9)8̯)Cx?es4Ek"|tT5SQ5&Iȏ&ęDH0:y	Ӽͣ,јKM1iÔں(|>ctȀHcM1w;RCnZ1?[8a={=sZӼ7*/3j=ld5E$oGS^MzBE{[jMy-Ww:'ȖɯVIi&$XI)OB:آY"u}&	E`n!"i[g'[Jɣ["VH^]-GwYt+^Jz%%o5'
'WᴚF}*V~]|6-DoFn*R;vmb_\^b39.1vWȫC>ţ8MM(_}"sYf{<_d?˻BBy\\^P3Bwr6H(9J!2|p,L1ANs
X+sb.Ty	N.)`E_d$ڝ.VJ=],r¥LKMM;<&ؔq6C'lVչPs䗐:6|&A=Ͼ	(JPG$`RYRRX\,&qY\,^dWsqy]
C\̄W0j*
?[bwG gҙ*F:jB
RV]*f
~Ip5h6A\ޜRkO4f
W!$yQh	|"]J.2IK=D=DN³"ŝP{kD:	}Aݨ}A
PKR#J:TǸ4K[hGhKETX(8n1n_?XplфMIߦ%&|qP= Ƈ.|7o-^x?a\ǃTN0??%<KRRم^>LA+v.lPC26̭㐛Vp2Q\Բ%t1	驍b yeKY&&;Γn<Oo0@-ssrdɲS$Ot",6u**[(g}eI1^Zv˓*kn(dYXZH́O= #hdžx--f]kŒQY\elbh%o+U:*iu?u?~gV۰+YGgZCFݐ^	nB5^[}:?gu%/~nwDJxM8&YupZi~g^~*eAsNK@,%Vo(ry@Η |39hT2r9=E|kﲊW/w˝l%Ux![p/F|O!P)-bӱxB(6􋝙bxW*^{gķ,'hmӏ?!>$^X}Ծ۸ӺT,Rhd
{(69yoV_B}-PK8<-{PKnLargonaut/PrettyParams.class|{|[G\]IW%y;;Wd'#'n%DZqgqd[vؒIY
Q׶JilvX}X`BKsfdY~3̙3g93wgmR3%9X44;S*<33?4JL\f,<Ph,cóX%SUSXXB,P̲7d}h=5t02
N(f]g!uX$rZ;
Ҳw}'|"'1jv3gH^G3Զ>YBWͥ,-SF2ISohLkrE(ӎto|([kqy4Pqc3m5{hGmb
5XX]c
R\ǭ3oɓ|]9Z%
7(>}LCjk\NjrreJr3UZ+mw~斴Ǘ,҉qȊlz6I
8ƚ
;1NW޸7fA:\SB̖UUwCxZ=,#'-q=UIq=Mk閑
q%"t-GOv`nrV?v@:W`nKሠ,z(aK$IзD†~r&x5ż<sBO-}3[*oDP~hFhoeCM|gsV{U?WM/jmc'Ċ'j+a'iOLm7gÝ{qc+BFQٹ$֏D_ўqb>T
g7сZ+j:7~rwn|gW-&,w>x;S
{
|kЯx+YdF]L~bdG**'mI	
j
٥swLenWoe\.uJ_q2ʝ@;=PaqJR2iBp{[if[
5<+
vnPƼҫJ2KyxЯ>O5iv[G3E]._KnQ\L/n9^0LvPp[%"yPJRoUoȸ-Zؘc-cqT!ZәIP_5y4p5=C򸙯6G&@9ǪCu˧u8rΣ}3n/7o9t~!!7GsZ2OY+ia0_rvYM߮cy~˻#C~])}EnqIA\XBe3i
6WyK&y^s0_
A9({$Ҧ,OV@\LJ\)gQٲgnuPf*g@dE!rw@~..u,k_Wȯl_w"E~
E?:AW&vP@]>V74s++⑀]YZY(51)X&tT>IS5m5cY.W_+hvaww¾LV,
Qb.#nX
zi=X(g*ݖWa;K7<2XǬpgz44T<3qٔՍt+3gøˍVd)];)i*6x=!ʂ|IA\kv>;wD¸Ɩ^Wcb\R_oC\ob{{y|-tP
v([|VIq}2EYLH.@z:{/+Ot)l˄g7}+7͐Jm=x]T>lޖ_67T뾒i5
GY'wr+Ge.7wZ+;vXH`S-j,J`nOгUju!9[2	-d\¾~$MPvH9W!U=<uMtE/^b=Bo	Jy){*Bk M@򵩔l<5-PO~VOs7h
38_e|KVyr\/߽-{գ"o>R%'vL>?H쯛r!EGެH9ISbY+Pۖ<Κ]`_ ^QW	vxO%hjFc0d1wsݖNmǐntl,P5h͂AIwMe<~rQE:vQÚЯ&GCP'N1N;NWq#q8)NɖNSržu/M7㵓btֺ:d"줃e͐Oڭ=܊>ȑUf9Jz_"y!4ڂ7=tB,2Qm{lb.LJ=^{p͕%t*=;Ϝ
c钮X섅8(YrSɤ,3LEMBCi(٦QS(7<HGGO-EO-Eg+['f(MMZb!AX'񓼤6Τ2Eaᘘ
O΅{Sc TlbXgxnF8
~طg6:4E}Ժ]M:nJu`fɪU1T)uL4Hѯs Mv9c@mIZ$Yx,a?8"M
QlFL-6J.a\CDCw]%ӗ4VHr
D׵*u{.*uP7
MLl)[Frz&@`BV%@mjk[TrF}3=&6TR
<QM9$-sIB9IitN>FB5}	JWja7Ssd&<c_|W$S`)a;epNp	)ٔ$i;#΀>v(pzld2,,Ff#96$ fBJ|j:\#J@%J31TWH?
UL
gcqlKKZxGx D0œt-7w䛠Al
= ȷm@Woo!&`ZKg#!AqB=Ot%u|#83?8lOVOڀO~n#? Xj[s
 K
E홊SRnp4</%jWVB~iH4Pr`]`ل':nZ4C%#ߒ?@v2|(_MJ>Ohe+͎͔0G_ꗢbJ8Jp>L8ΔŴ,i:L8Ζۆ9p18g?J5`*J198-U-r:Lw9jC*jUڎ	1G1C樲TTUjSQ;0(?C7D Jaߩ-S 4g蕭cq~+olt&2	.FAB(a0vP,CQL%3T6NzEHggzFt녡0gZh κ#:3ܥrF֭6b"_ L}x(+2q4dҁT@K,t4VhȼJPY=ct??b[NΆRJ<
<0-1ӡ-_S	дAεCezPqzF~0q47f>5⵵02R@@ڥ*!=:cqa
MJ!(D@m?Hclxj)RhN	L!W7eJc@nՀޟbsVPThbgUkU(},^	,J.@ׯ]kSҜjPԲ̐aqVf
Nw o7\ޚ2e;ɣxN%I
Zzޫ
Qq	Խt9 U6ǭ*%MU6~+JjD<%{J?b,2l?*>b7>
vyJVIxv,D*&+Ll]4x[gTR/*bwqp5o}
{`CV'	x"k94w_VW[EŦCc-Cvk4:MmhhQ~YK=&0@,;Hhr|T߃Է(([м!p[}wwQQsS5}QkVFUq%
T7Iֺx*WIpIkVO0lg4en5mxC
<MC
N1I8:4/YZlQ&#t\$HA?ASz*i/? /%pi)>MkS Hē|,bv	
rrgu͢.oB~qວz&t`ΎYYAu3IǮ 8=052؈#@
ح}.97;>x}q-EG-|lÊml#ۄD0LMvX٤R:Kh	D+~qc^۽%mD*Pd<4sfۄ"X5ۚSXXa֩ؔm_&$5X=k{ӐPjk6*5w,`muٴRXiPwa+ dҿ/QP3P~`a.֍aZ^tdzBe+YQ/7|d4(DL R
6ZSӋx`4
Sr5pXkn*,liDe
ʆXXeP٨J	(i5ΪF>f0:'nmZM`+h
k
F#H54Yv5s^eLcϪe`&;(ٽօdk:?xEe9<^25*`DFt,>$uD77ᇥO=V@eoao7 ĺC`J+A {;{ݭ?ݣ[mRZ&&&4M+tv7`oi1"qE:Y\̍
?k4e^ncn"vu>SuIa71TVcէQJn({i9-(Bcq'Xv')J:
׺['O^1R/¾77_񿒮ބS)[Se0t˞EwxڌߎKr	lz6!=ٷU:r;6Ei]k8l\.=P?Zb7$9e Mt$9D[$ 	8M-CsA_@;$ڼ!"//$i=-F~&N$+^@my\mEA&nGFUbxST3RU:EPbכ,EɆ<*}~)*eyevz\*[@Y*}rTTi*֩Q1&*do߯ݧ|Fs{xX43Zn0B4ݽ؅E;wHev[UR&H[2R4CRdI?T?o(}ڮgLƝ+jx~p9`	9uXX>@r	yL!]x9Yw<1!}M~iYӲNׇV9%#rk
LB^XiA轜lb
"S!L$iD(O#B9雅CY9)!Ll4!LT88\0&tNaJ&un}|E ziH@&[|Jn3)Q^/W@Uкhȵ5jxS&N%CbyM
krT1$ɁSՐ8cMfQN@i^ykr4ߐ`-Ra)Fzn\S6Gݴlo^S6G)^C5esʐfMjH\l%ubSݞJkJ-zڠV鴒ӝj^!i#ݡ Xܺ]}a!;w.fGH_oc'oE'wΓWE͓64<'a<9:'G5ΓIyD3OЅ̓mI.yUz<)!4ط*ݳ@ۮKh]BSS}b8Blt&v~d9:SW8Sa+dOȾDq{qeћvJO^Ӣ$xc)	ޜ'IpM\$XNI=	H]Ipvw(.7exeAZ}J̾Lιof!V:0wiX)Ӟ5v`&>@$b]`/i<$xKX}ӄM8y	~+D=_&̩toFx7Ohng	|ײ8ǟlgsV-qyϻO8<#N
,F/i>>G[!_I|l|0A-
mXi`}/%z+
x]3xPq6#&07/Pƚ
iAy&b
q5,>ҕCsF7MDVvnG߁e;z8͎څݝfGxx.p~B6S/WOrh\
t9OS~G^͡`@hv0O$s牲U-EU:(d[TI`w߽dyRߔW
ILdz	|BgE`!vqr9M@EkOi;vɍG4HL`qu,R'HOӍwun^qn#~$ۜPXs~d&yh!SDXq$#k8C[*g'U,X:o8ROD&"Dw0(VS~7x'@f^s`x)'!X`Lɐ2	{5e2$̗YfL!L^&1X"$8dګ/Y^&a\&s^-2ūe^&y5erћL^q_&^a^eV^at]L C̡dY9A=Cd'R9i\Z(CW99W>  ._DQ?z٤-zz٦_Q^v~*aOY@%K8p/_H~	 @%K8p/_H~	 @%/|Tp86Y=j4 e}Za	t]/$G	~UB2)>aș~LZwwwqM)΋D?0_-9z8Oe9^,ܟr.'9fY΅y z8JⲜ7^P*g䑊~,E*?.Do 9uL?x@콉GuاRAev%^L3zu_e$뾟>C=gP+9qRT>I3A??*>!){Y"H~))5	}3>MTi'Lac\ebAQw/tv,e[ca޽?$zc}	?mX*U]3UX5ڂbte.Z׶duGq=tIYoP`M1&qn&
Z#ߛcX[}jŒ5ID"gӖ	82X睛%[VrY8rF` HLeUR:a3
%Ogսm:`Χez1C!M]{6Mo؉E2uQrކ.KH˶VF8}M֟i(,
/Dp7C[&t}N4|3e5pYifb@p6琼`l	.UBdU8t9L{sH?؀
?YT5"(	xL6&jOvTSOޥpPdqا{DVΐmJZr3gWIDAU?[vMM7*jp#h:|hٶ[qYoDib_XQ<>978a4%ݪC΄SvAim0!܏nEKr	V:`{}KƂY}4U'Fxb+MRQ{?*mM䫷
d\|mAn
|3tKay]pt=We2s,9K}
r;_[;!
^^+b'&|U}c	<8Cr.+Ku=}yr
:
}P
}5J2b(H0ϣ[f겁>f؁LO+ofYŶ!1~բL_epS|Ϩo?9Z:Cn2wӸ4<\;p]ahz8q6
1Rٙ9gf¦ixlǡzeT
"<S6 iv";6g@@AN< /ldKyADEOEJBe!K4p׶\'|'z6VqB81ak_n^>s/_q/2љME<`iC|m厯xq(<|/"q"Pf*nF}i0h#5+8 Sr~g4FHPp	AR:i	:詿A_CZր^Q$ӟ0K	!Nq+JoүqeCD6XI\9$[ѮL|~r>* FԇR9.rx-cqTGcg8/
M渹zD96qL
VLYΑ%pUlOFo#TM>gzI.#9[&P*v-ήU@&EM1sKs4 mf'$oI	
=IuʫBA*Wl|z6>IVqл݁]W~ZLlSy<9qrFL"KVix_ZBD.o$zvJhps/Pii:3UIJ~ޒ"O'F=\:!F><#UYSY׶K
TV8|IQ*m>.ROw)?ò"Oz\>
_j7N`y)K_ѐXg`ឳAwx}ܓcd=UFU	GVF@ 52	K=७&PKRPKaLargonaut/Info$.classRN@=CZ+}H/_\##iRߥQcGؤw_ιG+g*ދ;4\pm~ZF[4c+mgp6j[T\>a"P1Q8Ei[s6;RxZ\:fHUťx`$o$2ELZ$d$0E{
R1MD,m@%OGk-Eǰa@HXȒ]J3#Y͚^W.ÜPK;+PKnL%argonaut/CursorOpDeleteGoRight$.classTmOSI~/vQEWQ
؊
TӤZH߆vh\SfMug`M̝3<眹~kD5Qcgߠ]\|׮*Kj<*\EgTK[}?YW?Ά7ϓ]߯u09]]_Sa7WTlRL]nGw!3ͱWaUPL am1ceӊŬ|"%Z2vF/**LDٷ}:	'3Ul&s;SY_L
WƬYy&lL)ʽ;WwLa2'PbrZd
KkQj,SK[1Qc4-f6$7([YIG
4Twm,84N^^qŹ{BYgo=+za5Ld.d>4&Ub!Ϋo˧D3q^dϹ`	OWE>ėUaâv_T:͟{%&iILȤj)zJRCI>{4LkD66k$JJ+1ۭO;q;bc'	WR+r(mBk{/(XRSCvrnlJӥ?/>f+hw}wQEЖQmEʊDD[(hKXY(L#:}a;'z1&6˼3Sf|[,צؓu쓰f?ɚ>G	cJNM:##?mWdkU?gM3P_CQ_Hy4
9
agbP0qe(ƜzgSC7	^|W[;߷JJȊ<}=&F$_`@΃K/Ob-Yp_TGbx^hNg2EZ͌x6^SI7;m$ͱ^8?_3^3?yMm!STO!6
Uy,&VVٴQL$h"]g[nd$/fSQ")p~˦ӊ$F@x-$/MSn(_|_9j1پKOϭ{:CQ`ٸG>AGGya-Hop([L:y+XkAm*6B|1g|TVh5hU<7y$yK~06Q%*I>48ECGcΤ~)N}\P`-LϛoRC_T`wYyu2sO׌xxȣ
W0=Y[mה΋ļ$VU=SG0(oIzt֝Dl]oh3GgiM6"JNǾLO3	{mUӧּTeʫ"w)Fuܯ}q >*r|
3R:giV1o:}ĵux6cَ'0xCH޿B3d(csȧ{߹s~i"
>Oݵ'}ﭭB?	|~H{볇VG)+[T
4N'

g	-GSz!r@U\>m:qdXU1qߙr3U4~mO?*?Jf<;EV2S|`+Tg@n&m?wJ|FY~?oU].qLϮ֞Md?RI2#͈jEk\0.'zAw&iHƮwdU[dtl/z"ME;fQaE/yMC _H<w-J,mZcaZ&@3ܖV	h˝p.#֨X1㈼
x{XoJ`4$FVIUbtСPŨ(`<.@OBf.]BbYyqС\131] ?@oS3"ca9V6dᆑYT1p#PYcPxF*Ȫ0p{ ,wh]yO zcR];'f:gEZWɥ<2q9RlZaM0͂3f]fE[Kvkr)8zJGI{?44/SN=IJb\Tx$ǚTҹնȺ=7-yb-Mw쟅L.#y' `uV'M=2;>Ǽwepyi dE0.1mn>z>H!x-/7o2W$__^BTzŸ/tmUTس<)Mok3X4SL{B73l!fS\3G[Sm.ml:HdwIɁl5mƤF@}+苇LY~&yɴl܇b61EdlnC C~eq=}ZxNNRf]Qb0y-;g[97M_mq;	kZUXwK?"4]*.O&(%"xi߀Ӷ)GH~tF4}Ԍo!H72-GCІb 
4I'9ip?_x#OL+kA׵?~|C	l`m;fmm|O@ײykTğkZDE~J$N}%@]sQO	-J~J4p:'p~*uES=
?|0A8Ͱ9!>D4BAqh~iPFxCUh$&nFzr&]\Fz,畩fDq!ny?Miq9Rs=cB 
q痩,{=P0dz:mXZq"ƿda2'-0symdl;f_x&*	,[u*@_؁]jRpgũwF& >qm_b
_6l[r/߫X"Z:Laذ{[fp})*L1V%&rp}6
Sk'^_'-,_
:"\onO
)<7fl{6蝇f*d}	Z
nZz	nI~476Mdd!kod H(5/E= ]8l޾Lh-:Spp||ا'iq&#Pγ,XvHw $~t`a{7bK2~ U>p\l\'+&;
3T:
ZvHwxrA7LI<A/a1t;4D-*8$3y{W`D@fXe}>l3=^òuI41n*n!ycgޚG$fݓ0;U̧??S6fMgwMzz$=Y9k =nU!87
‰-2Y}EZf$5l .;)
'If^]o!%Wg<(pN`&ڶՔfAC<0|΢
~]3I'.m`cvoa	{
>3~~tdwg*+Տ'Exp[k+M hba$QPcz ",&4$TI£Ap+7gv±=cɀ;11&/t{/!>Ɣ0nt,92f[^/bINe$([?.Kwb¾;SNpgjjHh/nM@sQf_M f;+v%#MަJ8MLFZQЉMZRXυڏ0c	bbsvj'Eu'MH^xb>דut"`S1X.{]'4yVllRN8,YJW9L'"f)&W&	Z#~]	6Nouߤ	P!8`԰]*~.0\>`ؽJE;*^vٽ@vtOAG`OYG'3ټ1z#fï`fl?,C>_Zv_XsKJGL4[(j??DR#6~G1.{iCW͗4_c/g]Ҟpc$hkdfQߝ0Ke/n)<3YvQ{K\Izf@7x)Gkk7ʼn
o7_]2?DN^vvPI[{a%䝺mᇾ?1Q%kφzIƉ{u?Tq0<>za>2=,JpwH?(g7)72IqvɊ}BW?DL0~߷2 "=5O3f>Bx
o#`eA=nx	3W;HgqN)ao[=xIN
鞚v1O~H?3{WH1lo.H}0d^;oOtYT{]_|["S}K523u7co,;auU:ף(%XdzyuN
=b=Q%'ޙ7n	vNۡ:o(!]:r:_v,!)y%}Weފ3Mx{%|/EGy>؇k26Z?	.L⚒gor	>w:8̀}L>Eqم_fOr֕ع+[/{KÈu!66Nt7wWN;JݳFo%:lÜu/[)8K'b8qpRX؆+[)-$6Z?Og]fI*r徟૆Jj,+})Buru'AϘ\nð"@/i{O. Oݳ}dwٝv'tk^(%!T1/V?/kH'^`]a6IuY~}J8>M<$]H' /x/o,soIoߏ}cgb<<&xy(|;0Fюk`Ή<Ըt|{Ç2{%
HroK2Wdr̕fouo,|[1kdGϻ{D@[Fa#o9/Nmw|K41~]?Ioe^<0͡l7-vH3mut@.N$3NNAX[:i=6t2Œa~48؎214ر3Y:bi>oO
9^:q_yzd2|,ݺ
ERp߇0pא~Db!ˇ#m1[?ɍXS~}0iE\zL
\H)*Lٟy*=deK#>qiƇHvջY0Ҳm^!-.[%䏒.d3-U3E+9#7.Ke7
]t?i_#OՍ˃lj_D^^W/
'i:j?H?$;䱁C11GP?7vdԃ
ʻg%GWs0AAzϷ-?Rw=nxe~Xh?o~H>|	va(q~IyϷ[G9OHP޵I!2i)2=2!
/woZi-3 q^[AyLRKs]+.XaƲ\3[}tʻV\\ϚpuyW;ԥ=◇ȻFՏ+~ygWwNxŰ-vBչSvvn*S!Y{.*:rF9?91f6QQ'#d]e$yx@sHP~Y'>Hgô˷IrtxtZz;keC=%a5{]*҇YxT+I"Tjg^m$e3v*~uX>?IEV>S-uܕ7Rcxc
er&%_ٻb	.OnQFsYDhq{ٯ(z6,驄;\pɌIEU^ҴEAK/H&St]!#wo%?+^v݆#.'Hk#HW-ݮ!EPM
#n;N,(i;#"aGJOBJ:h_Zy+&}w(.RL(;};9A͢*#"V.%WoYOlT`}GFU_~ns(kmAM0XHsueu//'0;c?˒:aBA	e5{UoX}$c]O:pJoOY[Щ!6b.[̷pE)+ɷߎ޻W^uDb*"%ՊCLN«*y%]WO{'A[ol&aOp
Up|{;>Ʌ
*gaOEDIX܇Dv2~'X̰KFw&"x9ߛht@7! C$mͥT
)J;pcGxA?A-
B@NJHpC6EV1nI(58x4CGL'Hp]/gtY$U7,da~^u$~h#{d3
>D܄#^ߙG*/:GWAQx1/R0NjHpC6Vz~
~NG]`滰^/ |c~Hr(\]x	#e"oo~H#u\HƐ5) 5$3WT6RѰ7-5$ {YWCu6taѿ|K|;$[G{x}*Di	3F)x{ϷVNpcHghxj'xPn(Pok~C/4j{hgՕW.K|;6{j!V
xKր=G[dC:!ݿU5zF1p]q:4b	ن>oxd	/?c48^!w13o4T>!A<velG$;MlG0숮؎Z#-b;aGu;	
&c*0-ltu!4FͼwرUL֢qg|{ܑgƷ^@=@$N,(8/zX7mfB2
DBVݽ֪ʭu$y^
eUѮhRZTdN;3uqښ;~\GQGT,.(^:gTŷ93r*[ʪU4"P]\D^~yCo`iTeXC3wC3>2F¨ev7좎jRkcKn.+xn	]3~yd%ݮXnIT6u뼈t]4Zl3#spdh,ve>L.qJ(_m-{GH";q*l`Ѣh`G)qKTxm\cnH#vK,s؈ܿ女_h[&KRG6ȣJ6̥wn%'WQBsx1{
='
>%
3OzHzX,l!|{FtXaaE4y*|cj&h%%&S
ET/ôf	y*GVx92n#Dܦ/jl!Ì|SUSo
O;'}4i@.(2#<ɷ}Ҁ9&Qj/~T(i7JxX|䏷Q_
c:3[7jgs+4iBIv&
ب0|5k`b~?>icܑ>4 #$kY>DNtD
ċq]qV5yʼnhţ8R@
'ZnE9e$Z;՗؎tnؙf
;wwolǰHvvSlv<ÿkL[8*]׮j{q?n
^,nj}W$oXp$އrƒj+y-r7?z+WZ[,E3s/b#TnN"YTј5VR9"jsj7c+[bF-ZX.|^m)حsUغ?	ݒ1!:K)ulvj>+a8-x*LgxsJ$zx̻R]#nk F'_ۍpzrsʂvXuXsuLˈ0=^e;j5PG>s:xOO}d&)!kC.FhW0vbaLD5ja#h\
:ݯمaXE}RoH/6{R;D%/Kzcg%gF!N%sQǯ%}WCJLǯfإ>fhfЪ#}V,jfxA\Bv72~|FlkAAxE'tyzE,O[5dxf&yG!J>G>Ã2q
?@MH:1^ԑ>`AKy?[`_~(X{
:b1^x$ -,D7[?`OrxC
x{BK1i?`'Eqk!^O/|5|#
xPiziqpēju0//xoDAPOZ^v>#Ag'b0/c[M\-u%By6˷+m6FhVi0/탁6qpēgj!Ɠg?0z^oe?'6hfu-`m+
"R2|[D6fM7"E-Gxm#m|s&_f1Fg|_^ᅾuQmDNL;P66%Cޭ/QJf^Tt(hFB5d4RwyYyh$vFBa'b;sۡ:vJÎގvvˆ9(-Îcu;z,ybT瘮{?̭p\3{\_JٛZ5v<~zSϞ>yXZa*2&ޅĀiL|q7߆vҮ{֬mGXo%׳ovT(1}iS%愳鏢8jI>ݶz&6tYk;\/R}+x?bbJ]ND֓XCb3H;uorīlB۳Xڳݜ?NB؉cLyV]R`szGF='%l;\ !idn;G6ja(b#":Hd>""G7X49':[GvQ%Nn7KZޮ`
}YcJpǞPxΣ3#&)),)
n g7KfI"03#F9}ge`/~kd&	91~c3pȭGgBpȡMn{^)ouµg 5LB=go}-uTxx-<1NS*'_~x=%Cgp[-ijo6Z!2Vk1|["EuYUǃ0.n\zt:Gy1֡Č3ZlFPM„[c:C->[;ۡ{Q&9aرF;.ÎZvaGeu;	V[1n4yu`^ߎqKg,P16yvj})*p{2~ꙫ{~uw%]OGoݭG	SX]p,ݎϗMQdŐt
TQ&̒^dEEa[(
5	B:q[*PvKǼo+Ol\rt,{-AIq}w|k6֖_cw
RxwΜEW
[rKN16f\=rx\GR7IOI[Hoz?vܓϕ||A[>KE]z/mbsf{c=AGKx1e|ΏؖݤWs??좞#/
S+Lخ![%"E[)u"`ϑ{]]Ver/Y>Wʋn%KU w '{b[9Sg
/`.8{YBLx^9RB"fzwH{t=e+a+L$9xުtHѽ*렎:xnL0~cRHГW|#^1c	?$m2/F\眰_}5LV?$^1LYz/="d@EW0%	ϔIF`IN2-nHhBo1ԏ72/EFsķ6ۙ$^_W0<{@rFXHн0{oH&|s.`bd>Fdo^_Io:^{:uՒvx]x}!AESo!$'2u`u|go^|ew|l@E"뷁9m2F=%Lm7h>4]`i`>_xow#J$^[G>Zo`L^1-eó"O7^>lj2K>&fp
guv[ߖ/>tJ\x35_GIX+hFKs]" u
 Fy 9\B$XF92z[ccFa~Ұ
b;İHÎNf7gqv@iؑ104'5n9>~/6dD2qK'Oz6UpqWn!iT
]
;kas(YvtنdV?6[r0bAޭ4BVf޹]
S>Iv+3='t[YT#KZY{E;jiV {O'9ݟfH?B^#h?ּ.d؍}5~^˰K~$[/E}FQ7kwD"[/9\?^#?b{/M0s!9{17鵄2g;Q<*lCR0_ւOOE?tk~Hxj~S滵ϑxnqQZc$d{gfcU}P*>3>"^2}Zxf3vډ?$=j:i5aIӾ󽿷1Hh'\vO.iGS}пo8H&C35qv]H%ᮉn
|d}n
}dkgݿQ>8~5>CzJ|{5vzK R]|ƥyaB&RkPDV/3.ňI
C\'SKMxߙwyFV/3LC鄀Zra3.s_c+R;Ջ,Ji]ZUzWcO.ӸnxNe%m)):a6ilUԺMK~$$|V~#!89k9Z6)KAHN%ܒ&}ZuUT
IF:e
koLLOZ?3ֹ]Ayjdx"yuW*l'|(3#Gb'
bEEckc=͐LEL+:
K¯CEjGvQPS_3~Su.C[ok	QWSTmy
3\H˸m\r{ G.vU>ra6ҝPjMTG+h|Ng#pK͓B+jN\AqOBG.IB7&nFWCK«hx@c[0zhD\:})6xm	I#Í(>I5ACN\}hG4.H葋_Մ\}d{(~s#?ݹBݱ98z}OCo<ַ5)-VIÓ#6ծ|:Md'
Ǝܤђ
?ܹf[Oc0^ZO%||oq-G2-C[&gC~Ex=V05k\76Ŷr55Y

D?=;׷7:!snW)w$mk3z~1d\uD/\]yz쓮FZ05-Z}[)qrd5wCrohrW\zd庭m0NC3Tɽ= -kIdf5վeVݗV}nDMam}Wk[A-I\u*AM܀~Vo9RL>ֶdI*5ֶԣׄ7յ
Bm׊╁@~]=z=[c
?X"=/a~?IK5|!uk[vxvCpm,m1!N$("
nh7GH}bWA;5g6$FoMoz%-eN4BO!B??tڃݮ:nMγ93"{W
k;76Z4v8zX/e>GÂ_n	$Khie~q@hYM٭>g6hw8Q4s?6~ANŷ#>e!$Ki]0Prcy9ﶗȻ
EÙ6Y8׾
7QvtAVɽ١ɅE!εɽ}܋Hs[w|:/!'6C_MtI;CZEf@	g }E;Yxs^aG=doK(Gw7{S^a"&%uL}%#f:2#CLߥ\c1._LS[6|1x}&]BNLCG/``w/FvQ3͎GR_i UK'=
/7|2}p~1yxěmru?-'/Y^C
Q-'_{p~[T#MūNXHXe%Ւ>S;?DΠI:nnqZ_kFc.*Mlh}|}0ivukr|749E=[ۛ%Bfdb~0ȸU9b$wpdۮ6z.ԉcV{𬯄}QIC6l@h_XWrk˰.ټ9
Fɑ\s)V{ףg#+#[~w]Q(5ZoyN\;	%n$[0CVYNYWB&.b;dLto]d_doDD~z.`><-Ǒܷۚ.%êܦVvgI.'\A
#rEUnAVȓCC#+,Zy`'z,싼pâ.,9G(VPOE+bީoX"IE+[ƦAwg!A#(ZYt8z^^hewjʂ뽶##z%x=E+QE+]%R pFr-TB}KAq.NE+ v(dX"oToϛ
gL(ZY"E+&?雼"¢I2^P~\Eo>g}x3ZI.{f8k8]`d[L0bH̰u!1C:12I_cn-Y8A*'vP9x\Xhj4:rb_ƒvv'eej+TpѿNW-/d#z/?7tzڒd[,%.5Fݮљsk[m]Ɩc#/lȷߺ;x+]JJd2z&F[nZ?1A6^&o*ZѴY;h4Xyuw
H兇չ-kex|Is@i>JSy37gn̩Dra
WƎn\P;)fU=).D$7t`6- k4 E0]D$޿ TCxgro@^ݬ*7bDraGI]aU]a@;G^	̐ԏydsv+ʰ=IKwMRa"^>3C:ddb@=i>,-M}hx^~	=moF(~?K:^O5J/)֣R3d߯MˀCZ>,j֛<]bv>,1HG
?6`<^aV hw.6I0Mm&&h7j0;+x@=GR}'(~؝E&nHsnxńi9\Ĕ}A׫玆Ȼ$^Yv^xہ'ҾB$X}1cVL[.3}1d/F>.])i{b49ὲv1& r{񸘣ɃJz!-stvR^v&&|.dػl>%VDEn_?1O놞[WCEKsʙՅ#yg#LxX/Nށ6zؓIeuhGL此9-
q]n͢y^ΦKɛQX^+7d2MW.LKrFZ?Bۇ٩RGr]5nG<3Eo[v.Bh`ہr?ZȆxD0A
n0N
ʚlܜŲ!H&VM.A.!.Unp~&תBT
hr䒣	
U
	M 8ړ#DoB BRuQ=PࣉĶ@S"a
z4}ϴT
=83/h"9B
BA"!
*=Hn"F)^pG&V3JT=8[5
iф
_*VPQHt/@%]Ёnp/6{@AʻumA[
[&h7H=o8e`u&Gh1]٢GLuq-AyS"x Ń;9bjqkr59
&Gy`rؾ8o2uڶ<]7"o4muʻ)a*m_
d|7tw*ד޲.u$y}ź}spwZN>V|;bLAxojglr5j}t8sbAh2ֳY9O@t"nѭvwݍLk#lSʔR譝bh;=|p9zr#~<2toLm:(ƶM=O=kbdzI05}L.՛7vh}ת7?,
*A*^$UNEMʥI%TNY9,kraAx\\rjrEێ	+N!vu$]!~i@{
_ڧ]|ao=E
/EI ޳ɻ_>Ί|dKj~LҪ&'~_ kr!*$r,KTγ"c?Kݎe~r-캵=cx	Eר5mAM{:^Lm=Xelk?vq}a5y*bƞ5~14:~ [?*~BxG'NFKo-֍==Yn]|쨴XQj2t?;:ѱӑb"rYLMvC73ˋl߉gѾƨ4=KŧZrۺ^Eӑ@K̳ɣbx,yb=_#U8O);:&({n@EXc
Y|̤U
݀zKSф>޹ -@D۰qC;OXn^{I*ׅA$T\Au?dE#b͓NoGL+gq`?L.d?ҥP[{FW=9Ab? {wݦx܆x2W=ￇV+]k^̴%t.F;!`$rR'c=^zH86
0ћ:p`mp
(O=SM9A`O/fƼk+,
.i3OYb4bg"3/bRvXGTឺ&)~p"℠~M)6;M*4Bho?T6^h]	1ČtAW?ô7!HdW8!H*ػG?+$ho;z%ʇM|sh	AMM47!65ЏĶO
n,S}cy q"O#ċ#xÜ[_~	`«[E}vzm0g6g3BچSXߊ	uoz=̙C?O}ˇ-[}wa}Üۛ)HX:mX
?[0gX7HGHn"Z𚹀	,RyU\zg$%b7u
z47ʇFjbsZWgLZhC>*zǵMSiYQ939
Ϩg'xx\}w;ޔ1Ƴ`w;SV%8
>)Sug-x%hGFLJc^OVDjorLToݾәIeGAW4mxw[Mws)dZ>Ѵ>fu'?9떺'O[N'-p3jW
;FS8
e_p{g*5ﳮA
Tz*oYo4|3|R߲Ԋuz{:zb/-䃏t`XxM-#P>`3x][`w`DkoE 6se|q3.b/щGu1>N>0+tav!ڠ\>y3i.(0ircA6Av!ڠiMf\w.w(e}h-DbEBA[tv]ԕ{IG֮!X4~[b~=El-|~*/ε.p"۴0٤iDD٤]Ik}
p'Ru6MCQ|Z^k]
CuiW>P7qřֹ
ûL>o@Z'aj.$U
3;6kZJs#3PlxuU5iZJǵWJb;6=|Z|xugZD>P1Z',A"FM/=9EOn_|?e*Ԓա)3XP҃{&Xa춗S[3=r7Mpa[&p5RT4xR}ƥQ|\po2wv-'sAsas-ݜNg
ΆG|6
v7~CcXN-MNw
~{゘M/ݛݫ`$NlN}{Ζɾչ`ejPXM;o2p,=w'N-uN?K
{3$MVH[-჉goQ=tY/h']*-fd9\.1͓I,ףɍ^K
ݪ:SMrIirjr䒪O[zi< ]$^mDinG=$k&ߗ*wWNw
ʽ^U'{Ԣ7[}ЂIn/!ʽl!Uٶ$/W3DxmRAr@EFK*wm5ނEX
F?k*9;-wb9;r_
PcInai^xeW!^$`bIW-CG~UE%Or}R^C
@jn0Uz2$tT'jxB}]5*woM!CErK:W	o,pST:wbp1 FLPzS5
-[9و,u?շp@@י~tU.Z[^
mv-L'qђ{0Km-h#Ŗ:.G*0oX:!jcF-ԣď^~{8@ǥiDc}o~+~âix7`?m:J[iD4{`:=,4 S!t0_;iX*Lf4[|4٣#]VQhmK-@ӭFВ}Zí&)R9X䴬jrfz*G,59x\5z
Kw&ZsP_/J]\hxĕgnL']љ`d7ҭU~SiLڣ3__{ܾ1yM5<
'\Qxu
m}#B=qO-=mց;-qіfV)ѕޛem0G6SY58;}sFM}q-&gw96ͻސq\N۽3DzpVNshlYe
im5LHqњ5;1=['lm
Sbgzk߿XT;;RSok"4F
?L=IIA@d
	=lH\xnT征?F4ނrI*a?V?Pz"}ydÉq,kW9M?Q?9^z,sN2Rll遚,ꀅ
2Éur7iUoj}y5ՅL06my1dƗcp.x0kI}eק[)`hȻִ_-pJ.cN0Ne#8^lR?ܻӷo`G`P۟I!^Ps}[&ď8^;n#̳GA}#I\sK3&q[T,vv.1m5
|lMr3!j˗[2v~gﷻ̽ϯ΅΁4mS:Xl\svgyP4h3-C֛Enp}ti~Ft1:re}%['u5s#!5\q#5glyp#6.'C0x}
Jh<t,jP2Ўɝ2(倔A.rƆ3y ATB;x+\="G\IHӐ
ڧА0sv$U1˫닞A5J_H!>PWӹNwss$U\q6
 vZ9"F_*P~y$N;w5ϓ槇(mHb>BC`ઝN5W1-O\\XԼ*	Pz$WƅK\qp75sذ"kxK?REƹ g
)xh*2Y‹Akx\|7?0OpFf[j>?Y!۩7?&aLMPg.]K΀2Yެ4grA)O\rg
?:O|8D'8Ӟp7kX%|6`mĞ9{3Zi؃au3	@ҌsڀQ"CMeLls7GR>lxIw_g(~.h%KKP9'x8'!^~7[MΫ$:	~Hf#MM\
8Rg׭O"QJR$Diجir"AI2M<UpRG2FW@k	%ڊL_dOQDplM4Ӻ~nf#R/8)~E7ďd6JbM5xFrqo=~wєpуz8Ӕ׭Lvqo~6_%6[ː7[M3}sA|0C2Cӷ kBtb}kg)~0>ȒFr:톆׃xw7U}lnj{,n"{\~[Bӷ9;q7 5}%i CI>ӷ.Mdh]Fx7	:z@42G64}oQ
c_țE۷mMoP]i{홆߻?ģo/-oqYʊ[~@ӷT;o$
_C^YZ>ϯZ)_'0_Q9l|-'i'hr59
&Gy0Gx_(_sQ97Z49YMNV49irSg==ykaKdNfŽV#q>%F܅@{X|)&︛wXObc΄%5'C;QwXƒVŖ@X?)Lt/<fNR;dg@eϜ=o;`ظܖ}3i|>(,Odӧ;CcR6^M&Cހccr
 zlV[{1<^:z4\.mY>PNok\n.֡k6+jڹ<=XeC!Kx&ۗmu,'P`[qq1+~'!2Gd·ø}نxu{MiVc
#oy\A[r#oe%Un#q>MԙK a{G{rA.U6cs#~EݷR
}a:_Zs(53yFkVܭx7	CI 	^-mS0oDVqܐ^b[[Яr.Nu|N­ۨ]n[T?9@݇dga+^c{㠆["n7gfeJqGzCr ܒqmAhEjC>gE!q
_8֑ŬO)vIm."0_Nh=oEV&'~_ kr*Or-&a#勚59)MN6orƺwSUr$f+{zroջcسKsN_kpf5cl	9CEҘz<;|
9;֝[{=ԝ}n]XCw[{Y)dn5б@1w8uwȗ7fr{GwozC͌eLd<˘7~;{í\tk:?̕q_ss{^ptXۊKTDgfe˰[,%\Õ8ȯaR#icڭ@dKa)c373=hɉ~WǠ{_=ʿL[鐿g	cdp~kcB̐;7XwIv6rHsS332ǥX>v6+bjM%+.xtG60,3~̈H}s{{~GгqT`UDFXDif1cUNDž㼙y
mo?F-xI;l8#ZxHV'UgifkF[3ܳ'Qe%z-P9/^?*?. ,IYbL
~N5Woy`Aceb!k/Xe%;%pB|XAҏu6fc}ܼ칸f;Peˇ=Υ=m.1q{hC&MDYs/9`KraKR2k3;ǻ,e-//Rɾ*ju+
Xm)>1JE8iczwpy۝G;%
*KV!VovPi8Kqd'^x曰*?o![я6;c<72S/gZ[l0/4¦	h/Mr[2}?6}?z:81}??3JW+e_B~'BTBYH+^٭[<`h>˟Y^e7.n|%ޢ?jV[D?~WŎqߘ/]2l"6L vҸWJ@3/~M~
T|FP?|U5M?x?x?x?x?x?x?x?x?x?m\lIJ}qz)#`ǗTᗤ{,kSSd%?G6/쌥}UET
;r|y9(gcucM&`g^NF^_1/R^P^P^P^P^P^P^P^P^PYs\D0xMf]45}%GVlۉM+<{k_A9h;ff}ȝ[
|m(\qvc?R$-aULrOLs%ɪGD#R\]bϫ,#b.5h?egZ0Sk6"c?_IgQsȫ\090+0+0+0+0+0+0+0+1+[Em1?r#?
?J?FG8+Bۻo}vqmGK>+}'|,co#c$axQȗ~/߇BmL,!?ɧKֱǫ٫붘wR?T[pDAPGv/IA?}7IRj1!cC1c20daÐ1rrpVgYqpVgYqpV<gK)
_5j6yCy*9\ɐÈ1DŽ!8K_b5&ҿ|W1UB
_3@ZZ5xVF_oY̷?WM/·gY%{Aѫ+2j#:\1<<<<<<<dg%Y	pVg%YpV"g%YpV"nLcV]-SU_l@$"8 R.3Z|.J;юڙa%fد.B:nzMqx5-Cq&MٙΊI@qwdUqyU1"0$cA"0$c 
A)pV
gY)pV
w`8~;p߁w`~%]35YՌuL{U92ўDGspз/t$;Dtθ@Їuqn
RٗWņǺ'86|2ĆHߵ3PDg_26A*~ȏȫ=H
q}@`8> q}@`8> q}@x8+X*MVirJU`&'G"痘C rmyEݺd{Dbe*(bدr`t?O_%_"?Dۙ.b=枮\6qU~ǿ?QMgQIHg?cg<_2zyE\vm'sU0vq`88q?q`88q"`/~9X_ru`/~9X_r+l%VgKL}mjQo>)DReT.jQy-N~9o
	BtkWM7/L~*?1(O$?j_v"ƗQ~*~P/.?po}`(F97QroXVs$`%9+9XIJrVs$`%9+9XIJrV󰒜<$a%9+yXI>MHf
%Ts"5'RY36};"*2 gkZ.ޭ0z(Q&kgzAo9_"Xi`53ފ!_^Yӯ\F$W6ʶ(^2WpH׆FF^"2#.{߇Q_m?q6|ԧ~A;3pnF壸5ZoMj#k#ȫrY%˂SV	OU|`X'*>V	OU|` u/"3\5g}yEL\mdmcdLepU%Z&}sRa/?̗W$
=^3h^\6C047v&xsQ\7|s2f/?̗W
CLBv'g3P󊆛hwۙ`E^g/^2Bk+Bj#k#?i#IÜ$`{<)Ox
S=`{<)Ox
S=`E+*XQ)JVT
R`E+*XQ)JVT
R`E+*EXQ)ŠJVTR"o8֘Dk4zO+or8L[*=VZZs2{//J
8)u9h$EM&Î	(_[S]7E$s//ʝqjIm⒝¹SzH!?r>f8a*
ZO:7o_&_#ag&XW$h߲3x]mAmJGP"<$x%#(	AIJzH0K$H0.!m˴U	nBV?(Zk6+_] ZL'ؙiǢi\X{J0d%%$$$$$$$l = = = = = = = = =`3II]fm_f#+'"O}@_3Wi捿M4wߵ3sWiFkN4ߠ`g/h%HR%HR%HR%HR%HR%HR%HR%HR%HR%$Aj'Aj'Aj'Aj'Aj'Aj'Aj'Aj'Aj'Aj'Aj'Aj'Aj'ajW7İGbb/zEm&ɀL&S`g]78}azc6;JopԤꍩm3&0$H$H$H$H$H$H$H$H$H$H$H$H$H$H$H$X"AZ$AZ$AZ$AZ$AZ$AZ$AZ$AZ$AZ$E5BvKU]}a*igRhfogWiNU#hx,^U8cKj}Τ.hLHIIIIIII73J`m6άBM&٬3Wi3N\Um6[py*mƙks&4<0u(Qr<@.\"Dr%"KD @.\"Dr%"KD @.\"Dr%"KD @.\"Dr@`R]"Q,d)f;*]ǩ~88>ag޼JqIg͟3WI?#C{;bp$dvf>'I





















{{{{{{{{{{{{{{{{{{{	..l3g UW>uhW+R?m6ٺjS73)39vf]O̤n&Scg
v7~GNu_XUxʟ7Y:VkUn>[kb	p~†gǑ%wmלr[s&|tܴmn;5\sVlw/l,2M,VmHxdže),J+wb,8b,bD8\a;Rv^"[aI	l6g\av뽦 嚂'){Y<#	y<v_)׬JF(d42EJ'K\4D\k.J梭dLƌIgT_+'}`hR[grQ&;eS&;)|`fw><2'b8YLt=2/2ow~k>r1۟Jsդ_'`"݆LvdLv}fW5RY>Tȅqtrp^#3;3;-{{)Lp|jeՓ&q,e2@:T SL{kVo|pw(.t1ʸxxL1ŮdL>26Tk.N+yC'-ZŹ3Mdt&5S)`Ia<5MNEfӷhݡsےmt
r2uxgƝ<³=be25xݙplvr&'uS#{	N{c<|TM)|G.GNKS,i
"3yKwK|HP6xwJj~0.E,웴rKm2l6k&9i՝k}3ܕam76^3NJw8:)ycZ}ܘa[R^3J=MMYɋxgxcc5tDS0E>g}k&y:!SW\LdL6de54@ۘX'&4LܔVlVS7.U瑧Rz߶iL6dL6wjzo*e)٩+ncߦLndLdk^3ML=U;7y$qL6dL6dmk&)}VLNN^v딩
2BZTjaWk&)}ݡ˜ڝ
)S{L+j$SdL5
ՈwznzE+˯VUXU^Hɹ%2MJg_{m	6o,+x/iSNgظMsڸRM1>h]XGQ>9~ow5gN!wte_PEugLsg+);;@9}ʁLŜ欱o)Dě/'^HfRVtWy;~eʉ`ʜou)~N ]%ҩ\:V9e"H=Rρs $ܫM]4$gsU>,S8Kom/l0~x)xfbtgYP˝]lw%^NK2:?q,2K`%Xf	,Y,e2K`%IWt-4gt!q	_39{ǔotE	gBP&ԟ4rg_84;qkٗxξtg_1ݝ}Zx=8FYOʰiE<%__הV	@Q	!7R{u*ǿO0r#-w!?u)	-!`e2rl\[.-`e2rl,ɖHYMO{V{%E:ɿoL1Wg|
BosWY0,k5sRzxfGyyy'乳~vg}|mw#FpW4gx<<'x%/+켔;rإ;
@{NU9PjC_jk5Z
V_jk5Z
V_jk5:_X|>pvɵ~ 1w_d)2UwpGܑwdYpGܑwdx6͝!씥)씥NvRvRvRvRI)K-~|m?w[:93v;sNiA`v(g:i!VXxb&XHb#Xb1 ~ie3T_1ZONȜ]`I9~K=e^kZxx-<^kZxx-<^kZxx-<6Ç^{2Cs%мM{(dv:`S}.h6\Wl/ˆl/ˆlT	_f/—Bl5[2[]$|.VOVs/tg|@wk|m;;Y|Q=uj١S<>ͣgx4,<{\:$t4j8t.#:կ?KF*JJb1#;նGwxU*w
]qW@U *w
]qW@U *w
]qW@U *w
]qW@U$qBZ]{L`{R%h11u`$>4k|S>)ᔏpG8#N|S>)ᔯvl/w)Y._IW/Y.˂xW$IW,vKW,HW,>&Y._}\\d|UݙnLw|;s
>ҝ9~׎vg?knj
 {֤HG'xGx<̣#ͳ3wg%[>'y@yɻ?%/H-P_[$y@}YnUɻkw[KnM'ﺳQmv;7_;Ɲrgcٻ|QyMOFgys(IJj"Pj"m&ERik6).ڤH&EZ&EڥRiImRڤH&E:MbM4qyp;s,Μ'3lw)]ZxLzi~i~i~i~i~i~i~i~i~i~i~$̓}'nDR(X?Rcܘ8<=bW]ŀC1P8ŀC1P8ŀC1P8ŀC1Pij}R-kHTEZ*jZ*njXjXMbvTKR-kwJTIT}Bb^b.Z*>)R)OKT5HT}FbQbR-kÚݙf;s֜ξNvgM|m;sp;s0wX y,k$x5lMUJ>rM]
>O)S
>O)S
>O)S
>O)S=ȳYoCRjKVuKV="[#[ocRjKV=![J^JJVIVHRRj?ToϤ~+~+~.[6 [o/~+~)[+yT5_)7|m;kY|Tw;6oꟿك(4(RQ=ӥ{IE2;pΜo8e3N3Nܙ
Nw|i(0 ]vMxǿxMoxǿy;<_SMMldbؤ$6#MGl4bsD!6AMAlb'Vt]t}9vbVms+οSҏXJ>f,/ԏY_ԥ<&Q݆$Tm@uPTm@uPTm@uPTm@uPTm@uPTm@uPTm@uPTm@uPTm@uPTm@uPTm@uPTm@uPTm@uPݖ%~cp{4M"giGQ;+cx%@
2xxJb'q.#vDb. 6>ى
Nljb#ذ&%6&
Hl:bP&"6Y
чĸ]z7cBI]_)3&T0Üѩ?s.cJ8kz5^pM/\kz5^pM/\kz5^pM/\kz5^pM/\kz5^pM/\kz5^pM/\kz5^pM/\kz5^pMoל#H>7\(Eb%(Jd%3gŌG3qPD}#"."".""."".""."vg/$"'L"kr2$KN&
9D7dߒID[N&r2IDGN&]9D$ON&CIPd149D]N&ÐI0d1,9D[N&''1MN&c9D=d1$b%'L">r2$'L"~r2Γݙd2ם9O&3Upg/.ug7tg7E&:$NۡK<^
Wy8:xǛ<6wx<Yn"vkBbGf'68Ll^bؘf$6 鈍Fl.bC8\Js;6RE9y.
	IIgu'?S٩L?ةv;N`~S?ةv;N`~S?ةv;N`~S?ةv;N`~S?ةv;N`~S?ةv;N`~S?ةv;N`~S?ةv;N`~S;-R`̳2=Ʃ<){.S9.{yČ⒡2\5
z^(%
z^(%
z^(%
z^(%
z^(%
z^|pgQ#|6j$F٨x>5gFlH<Q#|6j$F٨x>5gFlH<Q#|6j$F٨x>5gFlH<Q#|6j$F٨x>5gFlX%gQ(gZJQb9+E5rVY)j8ߗ=Ý9ߗ]Μ˞Μ˞Μ3g3"\9pَ.8`C8HÃ80C8À8]Otbw;%v+C]IDb;e"v]Cbw;'6;MMldbؤ$6#MGl4bs-R&'Q&Mi\̿(KTp5,vNqMιsƔKq>D4>
gA l|6>
gA l|6>
gA l|6>
gA l|6>
gA l|6>
gA l|6>
gA l|6>
gA l|6>
|)f9NےӸoIM5'nTy:)}SoFqc{Q=ՈzvOC}>d$
	(GԄl;=vj8}j8}wtWѕtO孈7!^Nq]tO]*N2Ɨ4eLUk}ToyQ]
,KRh/KRh4I]:Vkvݷ'Gخ}T6EQѮHU㻊Q5Sqen*oH&@a飺~xWoQx,eGU㇞Uarh9l6Z-Fa$8tїVGU;#j8Oh܎j8Oh܎j8Oh܎ft/M/GB/A9:djJGՕߍ	1U?[goՕJXu%V]	UWª+aՕJXu%V]	Lrm,IV5^Ugg+[xNު?j|]V'fjlVmZ
M[XaVm:oC]VMmh˪"]VMmh˪"]VMmh˪
=kitYeQ$X0b!X&~Q#~!I'@.~	[5췺Xϭsu:xn<[ϭsu:xn<[ϭsݻߜXOKv3$䙟g6Jv3?+%d<]{$_g6Iv3(%lg+%"X/S<+tc5*O!*+K&Ī+E"*O,6ĢI,`1}Xn !qj>ٗUFV#ՈjD`5"XFV#ՈjD`5"XFV#ՈjD`5"XFV#ՈjD`5":):z}Yw2=S/-.|D]#.|T]|qwH7{%?|oI7$.|'͟J7H_V_j(җ|R/jRٲG/+8f!6)@>*+K&Ī+E"*O,6ĢP߯ЗuZqo_&ݡ|ƳCk-(1[E"fkZl-b1[E"fkZl-b1[E"fkZl-b1[E"fkZl-b1[M٫ ن;*n,ݡZ-m7j]2pd%\` |Q2pde+W%I.0_\`K2pdM[LG3G3nV:ۡtNvh5SZMXml:bP&"6Y
Bl
b#O8I jJC
M,0+˚кPwhO5m+井^ԫ߳Wk=HQ^(G#zDy=Q^(G#zDy=Q^(G#zDy=Q^(G#zDy=Q^(G#IQI(x6jёNӬvBVݮWuARZKMPh͐KMPh"5AuaRZKMPh͔:BjBH	
&(:FjBkֱRZIMPh/5A*+K&Ī+E"*\ju>|ڼxծ֒mjyvmm7E#p\4E#p\4E#p\4E#p\4E#p\4E#p\4E#p\4E#p\4E#p\4E#p\4&!cC֝
&wZVݸkuT)E2RsJ)KRdKRd'UJuT)ERYJRd***Z)UJuT)EJ)>(UJJ"P"kT)ERYkJ).*rvmo][-ݮ-k|j9bqZηXFwv;vmeSؼĆ%6)1HXrl(b,!6'VXebe$VX5b!֜U7)H' &пڴ]ZzomFhf Hjf Hjf Hjf Hjf Hjf Hjf Hjf Hjf Hjf Hjf 9	I%l4qJټZ
VMuR7[R7[!n*nMǥn*n*R7[R7[7JTl$uSuM-R7[[n*jn*nغ]b+*uSuM֝oj}BV"[jݭHVʖ$['6;MMldbؤ$6#r5Rݠ}TAhv1RYRc
Ij7h n>Qݠ=[ݠ}TAdvv)RR,vj;.j;>vw_tί]mGwuށ]ٕN$v]F,b7;5N!v#]@l|bF&6/aMJlLb3tF#6e`,!6'V]ݵ4u}^swHW>=H=`0BF#z=`0BF#z=`0BF#z=`0BF#z=`0BF#z=`0BF#z=`0BF#zFIwPש
/"}^UW{!@R}!RJWI٫KH/;dH]$wȾT}!{!RuRbCzCRH;dHKWJ7J?*wȾJPϫ|j;qvw>gϫ|j;qݭ]L\b;ؕN$v]F,b7;5N!v#]@l|bF&6/aMJlLb3tF#6vdģ<tKkuyC)J:7_PC!}>pH8C!}>pH8C!}>pH8C!}>pH8C!}>pH8C!}>pH8C!}>pH8C!}Ir'SGxR_ߧ_DoA؎ʉ l!'}v'DDAؾ[Nar"۟AvgDD?+'99ˉ l#'9&9/ʉ l7ˉ l+'%9/ˉ lENar"-r"_AnA¶j;Oݎj;Oݎj;Oݎqtƚ]Otbw;%v+C]IDb;e"v]Cbw;'6;MMldbؤ$6#MGl4bsDd;r}G[l|_K,6j?C{Ox~@1u:`Xg3u:`Xg3u:`Xg3u:`Xg3u:`Xg3u:`Xg3u:`Xg3u:`$ֹUJwpש<\`
~G~_3JQ"vQ",g9D%bL(_(rFrFO%bB(rFؿ3JQ"Q"o+g;9D%bA((g'9Da9D?%bE()9D%bM(i9Dg3Jv_mv_mv_my:m;+q0q&v4KVb؉#vˈE&b) vOlvb%6,IIlFbh"6v~	_ޯC(g~~;w~?wi]`PSC!xj<5O
SC!xj<5O
SC!xj<5O
SC!xj<5O
SC!xj<5O
SC!xj<5O
SC!xj<5O
SC!xj<5O
%R	]`wi>}vtEX!ϔSSgɩ)MSSԷ=MSSԷ#+o?95E}˩);@NMQ߁rjSSwrjrjSSw.o#)(95E}G˩);FNMQ,95E}ʩ);NNMQrjNSS˝9O.>)<5C8HÃ80C8À8]Otbw;%v+C]IDb;e"v]Cbw;'6;MMldbؤ$6#MGl4bs&_']`IL;cv0m6f
نl`a00m6f
نl`a00m6f
نl`a00m6f
نl`a00m6f
نl`a00m6f
نl`a00m6f
نl`a00m6f
نl`a00m6fNb;:e'؍K\c.)#b_ㆸ3[滀#}nƷoJ"?.b
*/W!qaJNl\KC)%ƫ!q]_R}_?kRJ@4$$$6?
?Rbl!H4$.J) !)%ƗBӐĪkSJ&$VJCijӐx]J:H|AŐ0
קĕiH|yJIl|9$1
?RblHܒWW@!qIJq	$LCҔظ)
7oHHiH|eJONl|eBbҐxcJFH|z4sW_IC@J%6@Ґ,ظ#
7xabM4$.O)16.MCSJ8ՐiH|MJ5	#Ґ8R'!)%BiH9g$6KӐ"ظ7!u)%>+ukiH\Rbl\	Ӑ8Rs ӐcǤ!
)%^iHcAiH8U)%U4$xEb0$5
SJ!Oݸw룾F6w"w;Sn4TQ(ߚwT;HV1ʯJ(UwקT~UBz(xߕRyl|ko?c8VOCOTℌi(ߐRyl_5^VfJ(wtNK2~7
?Ryl7%+/K(!i(Ŕ_	#P9ظgrQ~]B{ݭWR*.!W|^5PR2o[o	[ܭ.OCT_P)߀7x+d9Ft=
R*_
"
忓Ryl(-ߗ|L(~(ռ?
O	4 (s[d7Fi(KU	cP4~J[ex+PQ~SBݭHCS*)!	}P;ظϳ{+hQ[TA3PcǡG+MV1oN(GP)ߜP<
R*gFo(_PGV;ӔW&d)r,gPϼHV7$we?R2>	P)ƿH(okʻii(?R	P7)ƿ۹.Y1ߘP~*/
R2/OC?T_gWz+do$?w4N-	i(c?Cy+d2F[ݪ+
R[2
)OCW'+oO(U:R*{B|:T#oo/$+L(UNʿR;2P޷4
_J<6~)2ě}cV)Z;x=|^STwŀ.߻+6W_lR(>%[9]Y,UDRVjv}{w}~7
{N}|:9xܷ<㾯{w}/i{$ߧq-o}U}O㾍q7<{3KϘq_
"q_5ůx.!}H=걶c[\ڧ<־ao5\2U%56g$,~pG{1Oڙky]gcm\+XQX[+X{vX]ᱶc?`ڟ=>ֲ-_J^k6ZZڳ_=3fJ֡={oOsQaDۙE[o2>j2x9Se9ͩ:TOI'UӇIAT|Ou>-:lSO'T]I,Ԕ|Iu>:RO'rTi{|Eu>:%Q}g4Tsw<|v\u>:VOgU(g6ۙ]
Y3ѱ)TRG5nPVO&|XjJWgտZSN/x/Sc*wiox"4qaոK)Q_c/;jqx@Q>ҪSQ*Wl&lpO0y	lb0de[X[>~cNtgSڙtz,nKֽ;;9^`~ES>5nDkP敂ZK ߚ\ʡXZA.Gz^0hk+\R?%Π	[R
Ft>{l8.l(5b{j''2I9>Sq-dNj+IbcE~Pߞ֓}Drq$FXq
(ăi=Y\Hu8ZI~MQ9VȻ/	!֓ ΕB?O;a~^|@e{q+D$Zp:X*V/e<ն#;~Sa_gDX.G|{Url䉇KDE87:7qlD	.F:KzG+ksY,d:>#ƴ~ZzOuω,3E{z_m(qL%ɹj-+T/1.mb?Ϋ.9Ozc/sپd1K/9N}O|a{wCϓ
k݅ёnLEsNB$!{B6>qP䉋cyqe2(}#|ֵc,7h^+"1Jz{!*#mg;זD`֤	Ḵ@"LPh􅿰y6YApw$ʝh:%m#vHCCkw$mx>:>Yމ_,ޖg6{N(
Rr<r9ّh ^Qz$$ɱI40%GRyy!!ْ/[4Zw
L{T8`kلU)0L/ޜ1~:ZfFSe\o,.mcG@n_v:PڊUߖ{j6/d3V_CAcrwa}lkc57Sdl\Xk@_dcgv_:#z2a{8zcoDŽoNB8.pAfodݎ)#onLYd1Qt.qE]\+ZQY6g; C&W*cPF[Պأjb6:8#p㾸:C;
\i[BMxRuuAt#Y+n+GZ;lsME"z760@(܄<偁A6c_qS܆~L.ĎzFT	]weh`-Z&J
0.ure
{1+\N{Ҿ94/hCXoԺO-#bSy|ߠl)xkijnȅe=ZJeT,in\*idڮ}Dl0Iz"០kӳX6>u/i5ޟjPjTah%Zt_,rt*XDZVǸ8HQ؟u|sF*wJC/.jY.}Ud1J
BCo/[@{J~L(?7'nb6f7U7\B457%/PK(Q	PKnLargonaut/JsonObject.classVVX>;mIv
Xhiը+hbHʶW90O33?j֚Pf']mkFWr>&_&̒] ~}5eCOnuN\9d]n%o:'r]4o=$JigMY7
VҕjN4PIӏ?
̜|JVU~8*FlJ`nKtlϋ2e:/g΄

ʜq][EP?YjTۑ\($ҧ>V.q?aR$-yGʢqR8ĭܳY3ZYåxx7|d3=q&o]GbIGUsB+Sf?&H8e{ha<[POOQ6iՓC6^
8W7t6
噸'm`jpjxA9;E_")@\:F:X:9u1Ys7QS#	׬=X
.3
z?^
Az"`}8(D Jm;JiՖ(ۨ@y>5r+8_"=nR
IA.k)>䬦\MRu:vs#$뒋|yljnjmas}-;s0zyZ)"ʌqlOfX2ZSqoeadDrrf
$gQ	Q3<ɹg_˭t
ۛ/{ݑueyY4n63Uk&$Llsg*  |6
d芇OCxrS{GmՑbzQ7:@Qi+vK㢮L?HfP7mM3G?+}1]*;_[3]7Skv]!i<K5剶r]$pZ^s}M.k/
1%Oi=)%Bf
b\jS,CɊ**.x@[F;$ݏ=/gacUor[n(:.$9%lgy%	<~_om[¾b`F?zkv UҼզR4U}qiFDYWM#k4ugfSesE3wY͚/퇯M$?_?rl愒-#DH0^I4țA$n92A+;6&7#"80#	[x~05|" ޒOM2t
XqC> wS۩ﭩIb;u3&_&N黍l=󉽉'sdF{ջ`1gp4d$?݊u5\V*Xxy-$#;8k!Ne,-,]rXԳ[bib4uj)`JJ2BPKO4i
PKnLargonaut/Json$.classysEZLHHAVl!9h041(8aݰ;%""""}7oӏ`Yeדewwv !LwO_y#D_(LXdH3N=֌n}S
t4Gp{j
G֦CWfez~Babs1*J1KkHT%ZwP#Z0FUaܧxѺ_	
EA&C*L3iM~.96m9یp8%B|tmST-!<=,41)7J쇘[W-uB>bN 県BL>5;@3?X70lhY+8Ōw>
*B"T弅!5IU:;i=\9Z
/G!|u|)Vf	]YOƍ:1)/"*JT챢[Spᾘf.Z)[5,]
pLZ[봄qojmU`~|,Z$ORΩ0獽zWyelȥp:㦷KNܗnpjo3

%s$K$n"/=:DHo
{v-4-w<s1(o	,\JqՔ8~5dGcLF,Ysh='YC
+p{5PpFp,	
@(/zPC-?Qsn#Tv/Y@N9zw5id!rwG.pG^lX\lC2"z٥UC@Nf_ٖiFjӯ6;\i7CƷy6bmA&7FK׃荌֠Ҷ:d`r=U>%Ջ8/-)UVN|M/UA2z.;Zno* JA>8xv\$b"g;-f
",{=!cF
H!C~8A{3xo	O
&岏+˜"(d_~-PKF88PKnLargonaut/JsonLong.classWs_	!9"se|8Nl]36qke06Dg:L&fON|ĐH}}g_r^SYh꒦Y |oW}M]J)rY@sMˊTPIsaS@RM,IJ^jY`OtBlvH$AhI"+|Wˈhi>xG##Qb8+((2S?6`%s"pg2
.rWkBtNr]d~#%9'2 _wOώD6ŋMTS7tHO(t͐Kfڞ[6#mMD8_MTݻۃyOW=t`b
}AL
P6T_V]_:..济>Gk#n:x;__zTd{xq,R<-Z{ˏ8a]gagӎWiA8V+|N0K$(kfݱm_DLYqBDAԺ\L8 n?/	d/N21oWl~}t[MOl63•9rwJAdn	Lu?})kbES|T4ׯ8bcnwD'n`ND:ᢤ8EA~}܉ +R "r;z5dl?w{q<
UY VUT*
-ͻxJ%]TBqCkuAl@K`-p]+Nv
Xp.hvCKj#Y%Yj=z..n\@V,i5C7GJ|$\P3rV)Ji̢?/P_z[h`SEml،M'ڌ;m$6ㆳw4ȍ9a]׌4fNӊx~}.JQ$c^U)ƺH׎Y|FC)Hj>b5	3NH,ƝTTE&p5tAmuOx>cĬ˧mYcA
*`N>=ųT;c.bJe,Hc-#'f,lA.ʪnN끛[Ԝ|ZWZUUfI01IYJ\6v[^-9
;qXAYSеZ:.؇u'HDm1	[p;H*Zt,"7@e_9
Y>r`|3zE΅rB2H^uxnwܷL-SKTCMx`PASg;xF7i
{/!
yab:'kaKdM@Z){P^f Zc=g}FLT_:'9 u!?+%d}dx}%,=P+xK.p9|!ȧ`hriV䒡M fB}kb0Gc5>~3᳸
Jh|G#m4|2%e,LHI.XQ҇TXŃ&4RUw7>LZoXyq:"c	hB?:HLd١dPK>˵PKnLargonaut/JsonNumber.classY{\[u?{uuu]ޗ}e0clc0n806{-$@qɲvɒ&ivy6+떶i`/ٚҵy٣^{+[\HBv?t9=_'!J8SSɶD<6ZVx j[TFgiIXfv'fըJ>?hQdkopLMVjRKpڜ',
3y;yv,˄/wOx"y\](!mB3S֠ǎB<Բ}!at2	Dw>u>t5on~R.^SyP\v(Z_t~mcg:gcCG}';ekbA!vV,%lϒpW*ST*X?SǂGjnP&_Ĩ9/!sT,^tq0SL+˥~Jb)\y|HcJc*7jhg`mPUTWs]eV4^TercELtG=e	b)xdR>6 sb@V{||փ9;I#_j[N2&ϥzZȂ2Aȑr0Kq	Aqˌ,̋5*k.0r|펥I,?Hק
g#*"fP]{g"
L|llB$w"{o8v\}N_"`Bl=54voTWcDVbKiVg޷qN%"57:C̙FܜA2U',v
O:A"t1,>YhE;N~5]
K
W,G'Kp$rBz7-(+8|qb	7=2`deE04DQFqFQ,,;ϊJ[9AґEq
zc}({ᔽ٦vw}VQ.`ȣriJ@QhDD'?E
(ģ
L-P."~mǎ
4sL@q
.!/movʪF;xaXQQX_{S|s"2Ǫ1!/
ÆTuKvsRifY收3y0,.(AcY&ust,esۦ8LrX|X[5Kvtw;]oam]ezH+kWULr	S1.y;Vӵ!QV윥QUٖfZ<\-
\]8ʳ"5LSBg80Kr}Ϲ>tp}bpЫr2D3Ce1/"Z۰\ݩZ!O- `Ǹ5+V-f"ӌ.%#v&¡`n9L|2I5I.K
{?L/>Sb*-مJӗQTYfC*=k P,*j'Aj	WTf r]P)	ʐ	R:jE5JWPLЦ@4p&H8-DJ# ,eЄ
4DY/.7V'@rBxJT^_{`/`]Rgϫa
qޏZ:ND3[9v܃(aZ]ZRQ[v8
R	<7?}'^;X-55sJŒE[Kb>@1{"ԞA0"#[2Q8f;@z$c<(:Ibϻ0Ć1%.e[qQ+*NA3
%fn
2~'Gu\.gâSPT}077g(5
:w |$qb!5JSh
h.R#$Fr&8Mx.ǝNdTgT:pSC&h-oO~mjs@ox$Ic#Q;|>Vl,~$75ͧb
:,

Ꜻr*cZLNq8E'qo8
FQu֡tRXNaOO164ҥ9c%IjRTɌ,(bsJtUo@U^7U4_2"MU@jFJW%;|+kvL	Pίúˏc'\n<b䂞Nn_70uMJoq@Y0v&u.$֑AFBAߥR~0~!769nj;_*ؤ
dSqZ_FQ7UL)+DᏱ>mZv8a;b+$ş
WpMo//aͷH_q7qPy;j.=A옠DO3m4,s]Jmjb!(C#WiŠE(3L^[NC;k*PĶh΄V`ζF$_"ru5Q`_ ؍Jwc 	*<̿faqrܚ[ũ1֩Lw¼gL
"jt ޥ,I`fQw|SiTlbpZ&8yu#,+P"h$;&=30H3PXV$Ta=NRo<'qK洄٩4㵢@gڜVضy4X{3*xҥ?L$Wh{a( փ&=vr*h1Xr&G>ru`t0󘺢.jIm%As*['UTvB5:n0ӌ}&5ċ
N{7Wg+kc[a!fVfUŴ@TM$4\ƌ$"hœ*kmbQ<@l>q!6C`8Q7~M~z [.(ǿ5P"+,2fbCuP^/GP7646e-^;uVan	i
~bcp%^}/C:򮃟R-S	6$Y֡
Sk0r2xui{Zv]oFLJ#]UB'Si(>WUˍB#>@)W&[-<0ce=Gg?7Ͼ^Tu*J2b"Y|f׀7a`2تSPSIuu0fe긁(
ozFL}
ȏ ok
Z37\Y/s/q|3{8mv[Ze`߿+{>̭aΥa_6`_=
N&#'-@=4k.8jǗ6d	{uYJ^Z0Zݺr'0C5؟`3eA辴E]h“p%1sVWYf	Vž)YžJO}͚w:+9rlyr&{
~?IQ3:7:Wux$~n4[zDԢTg^l16ذd
|0J۞rT|W˨ŃPx@5(/rC!>B}SP_wx~,WV]aTֱx4M쨚WSa.5	ׯ
>\3k"+
it[hneĭ_"W ׻VɺЉ=5uW_L\}b9bXOj6eBoOO!ȓꁿ͒\ӈ5^w:^v
_p37Xy9@R싈p5rM`˒
`T]%,mD0OxdO6ׁpz 	hd3]4%xX#ka,ڑ픜h'TEELEDõiinXwrTL,J"r6\/)L*򊒊'>=BF__%UbJUt֒;%Nin3$+k@
lm&C`8Г<:]!N|&́Ѡ5\9!BtJ,T-:_	4FCg0՞'{'H'(|/ H8qғȈAn#E£<0"XئiVoŝbߍ*PW(FA㮡	WA\aQ8
O)PK;
}'PKnLargonaut/CursorOpLeft.class}mSXM`P]+X+VJ,
"muJDERڝ}}`?nf3Irt:B0N!]3ꆦ>ssKrCbmiJKA,upl[R: maӕ6ecU뫪:J415/'A/	ϋ#ȈO=t!Fn$`Vd(Q>-jxq:Ŧ<3ES^ s'ل|%$s̗Im~-,cC	QUosLjLd$	:Ъ33/`:UTm)~mU/"g(s^9譤xqӧdJ}rچV
JJF>VCq64›y9@R畡{=b=e(ͮV+J8(M畕GkD}(_.1_Ʀj2@͈'{G3hk6VgtJ0Xg{kta1\ Lo/IWQ:cfO+&둠,3kR̦:vq΄9]
䬽>^={E13_O/VlzLefg~		ߧ3@$ZbJ'qޙ b)s\Ȇ<(܏%GDi `#Ѽcq*5H'{%mzz"D܆%&2`5
3o*:15>a
m0U4sCC}ߧZ.!BEUapHz+ofQVL.LKXfb+jbHJrni붶)m}`ۖnID"-&xT/lvMi۔#Zrmgאm{k/w6ix{ Fy5izrEjHϾ߹$WպzCɩm`J5z[;$Vs~tuѹJ/Գ#_`s^`>@F}ZG/0cƴ80>mGv2P=Q]j|ԸeS'ŠH.?9wmru.\`G9H/ؒ1PKkPKnLargonaut/StringWraps.classUSVM1!*/w@
-JbyEbةyhXLjzQmLQnW:d޾~g1l!2m[回cZ+"D؏,aV;ߺ2<x3az0;EM4QDZ/=E,qs&ʉ̽zfխ%TaV82I]+"f%uIg{k\֭V3]
Hr4y%A$81-xA0r/JmJbmW_N7AK(`0Mcmi$‘=e2a{bv\Fͻ4]'6Z!+*x^Tc
!cZWB}?
2C61qFة#We@(I7.C5Oi-\@5HK#f;[	}22 KjkeǤh>7vtcV8
񭛖{2'0Kk34,vhX 7sf~)jYS0ץg^ǦkݲlymtpiUѭZ6ěk,Ԓ?!*Al+WFyaf0L, 1}8Fi1JN:}  A߿
-BZh}XbDZ}￰b-}lא:ʀ2^Bo }9z@u}C7>Q>
o#&$х		kۡ^gS
PK*];PKnLargonaut/CursorOpRightAt$.classU[OA-"rSADiPZ͡emS[|L$f2]R46=g79wSxeL,e7ܮLa
Sy˦4
".IgrJ2'f
)J2|'%ַߊL'ӵ5/#l獏|;/!OuRe)/
”N24_0o
Ӑu&CìF3!B1H0sXŦ]/V!7!(wC=/Ƣr&cb`EZz?"B/.I.2׋*fhrk)h14+<0t\1=5*Pn2tDc>6at#ƨQ40[}!A\mw6DyoH&O2<؛WmE0Qs՟B#TE&h0Z-lϣge٦nqpVܵvs6MksFU^!<eˆAF<3PgΏ)[_t7id&uU?#8/F0FVԵw	`aׅN!]
gPZQsddcnŏp .xW(ch*Hώ~A-F}aɱX&;Dq
Zqi&S{gj"(zPK|13PKnLargonaut/ObjectContext.classW[S>==]	!dm		K l2}2IۛH*TMeryI9=c#tOw=3܃_TڨZ,i]BsA3NgڱVB"%`3Άj99obUmzb+m_R덪6E@Ȟյe"v$:lќ=8^7p@8Y8=g}D(ETx["PaXM,GgJv_Ĵo6z+.d%K9lw:;c
SGj EOARg/MyB«!&p{l닦[%ee0MfBԔVf	p	C&ںΜK3٩&Ҍ D!I,per>o)Md3ʼnGvKנsF~EnԖ>
ɱtB]~'+4u^đzw[F2cMIna)Pn>A;2{oR0Jqr?3UNcFAx~.0!3-Tv+u/q/{4|)eR 6W}Nv$$^O:dMe%9\vF+}RI蝘w&NlqR<$9l"sTLG.i3>oz%ɈGƼ]{!t45[#nN{ǹD	!Mqn6e{>v\N`#Ă/Y(l$_ܷr7SIc[z.HKҝvzWo#=r|N{טd6|ompcQHSljX'GH*bÄq]R-KN*w9Vq9R%jzZc8-woKӊIgωzm79봈; Q"	"E~E-qr˅FBrIg6g
ؚlnESIEm;xz)pn
G9~Ɗji?RJ8!}R+TlJxF ~NEaXt!z@fgQ\a-l
_~c^SQ)jy;Gfs%>a7rQn7:P

+H`j>BX|s
:kzP(?u+DaЂ
ؙ`^Sz0ΰ2R4̆ޗj9՟Y8K0Fj(Bp$*C%?PSMDA{JNŽDQfNs^O"7QX|ՖU|s-ӈn_we96I(0Mr3Vx│4j̛Ag0\t]2(\>3Л;2ƠS76*	=V$XUYE?mE
O:lXPZ9iE.AH+8V؁]f]ر$Bcص&Ya|a؎¥$7EE8b/"ի'l*v}{`2g"ҌV?(矪UXÌع:l
el8(Vjf
%mqժƉm2jxTC;I?'^1WmD{
C۱}]0wq?
5	߿<:*?ELgQ,SXCÛ0_TT_NoC1X߀{&V`l"-p_/O񌰛*k0@W{
;ng6
wqp.K*NtNtzi8|
"xn%.@8`0[a^Uʼnizۢ< D(1jI7X?'od({bjr9YkFWV ߵLDžsc,"µ
X
]W>~1O;=+Oz}>6Y:PKu 
PKnLargonaut/ArrayContext$.classUsF}8Q$bHh[8h6&%_aG2_`[gG1 lg խ޽{+\k~aEWb`n-^;Po+l+J-.h!ݎ+c8|qAW[p#H2o50g{cu}Ae9pz08ZjC&HI/m`[H3ݪ9p29CtyzƐ˖{!
4vN
09x?ܦb|2$K#NEyYo+i~
ñлJAq~"9=7DmޚIp{W4Gy	:qJw)gb&TCQ0Z%nҝ79u(ugMM )ւݺ"OzUO5LUގB̪Ӕ|p	wNpՒ!ti6Rms"Zܓ\PfyUF$Č8C~}Q20\W2CvCϔ]!!]וlF
=Ċa_(֞UZ[5=K{Rzo36c]!TZgSД dS
St}eFFa]4ĺeAVBҌ(\E̲,jEK(wVg/1#(C_TIB-75$z=aD%ꨇAb`TWzUŵ$GIM
)&
.j\Q5cPxgqQX8Cp;Qy`
VE2Pth67{]ݱ>3HM2$g 2,,M;1o%.=Y&t…ޠMu碋͍m`j-ʯc.IZ4hd9	jk]džGfۊ=?PKam=PKnLargonaut/ACursors.classRmO`){AdU2$T`[:$
VBd?jۇ-هeP_2X2}99XQ1r10-ô|J)[o_BŬX dETz):ա{`U}m//
Dj}
cnNikN2UXc59/Kr8y8㶚̚\ǚ~tWf2GL#:K\=g=.R,',qRu!X6Eju9I8^^{\^ ._L^3a+URg7s$##Bt6ͱwףVUC9JFz;p/J	(Bb΄! q|)MҒh$L0)f\ 
3$3E݅W 32@h숞$MlbLOSna0ÖbjJwѦ{~[5NlWύӷU[5Z|OW[놭ؚ0:<;zDw3s47xSEoFor>ъ=G]8dy!q@(i-0b1FMsW~sc0(yCǽfCFyT%XtEtsU;
F1!*	|Dme47GC PK$!vKPKnL'argonaut/EncodePossibleJsonNumber.classekOAaمQWBZD7jZ+"J8kwga/6&~j:@+Η3g&= ns{7v]mkoDXk~{yuKap
CM:h뚢MkT9|	~VPg0zSG=V]O}V*-")W~ZL- rD-1"%ɝvPu7~y +i$tk[pwvwך ?.#Dj@YQBXUzNϿ_ee3*rs-)gQĒF[ҟ>gUJpXfH1#R$Փ'(QZ"Yy<惑Sgik+νZ-=cޭ}sAj19.D;4LK~gXQsۣh&|M޵3W ؖ	*S0-0	3edJ>
FA)] 0+3@LHIPKC(PKnLargonaut/ArrayContext.classXYS>[WR	h0b1n!ɲ-!@b3ƞFj$Y~y5G&>ͼ${]7?;:2[cE-.F36V}2YB<daoOVw Ķ^z8i‘rC.G:xZ'N8q+6_8w@!**EbKJI*HfI$DK~p),RRJn|$'>r*ǫzi/!>O,ǵXv@-Kg,7=/Y6OXze*xI2͉mCH',%Cۓy藽#t[qUjz'w7X,cGg|ĺ{>N>-JJ7Wp=nuGDg˕L$Mrzn]έ7q}%,Hh;xu9PYZ]%	I5@|"65p)nSde=6eۍ_5 ~>z4ZӋs>jGPgZ0yΚߧcHG\`6	b\]G~q~ÿwv[hSI]E̳'~S=$вxҕbZPr'ɀVt	t4۠.]L	t6t	.hv	&0x:'tqwգ%6la#H2TeM:JmOB)'Dn
^K@
atB8{3#4:4tM'!@k?)՜0$(R4ʴxKjFגvL1*OpN)VGw&rYf4o@6RJZ=K{DeޅՂpxV֪
\u7)T1U3]Av NzRWj![IgT#l0C
f	bX'Ä l苚E씮P{2'S̱-7L10~MUXX'GjN=)<>@N>(d,7cO(r(fU[|oB:tE2O9A+2eɃ2uBwQR*Ɓf(!)3$B߻?#982R: &\A_'-
 3ѱ@'3GiNLڙ~~Hv4mսg9H_L9fV:1tV1ck{f)_

<ɚjݞJ5c{^Dgf7V&B$	O$Ea~~mDrqnG#C,Me9I(OIgZNXuyÎk]Q\|@mhz2'e[|ߘf\l}d(ۅ~QY!I#>g߫Dxtdk߭nmS~nLdm8>ёT
lM[N2`TcTDJETֈM61"4N:(*墒]i^T8Iҏ3X'H
s ƹG$9D&DePSǩa,MxeoH	=Cǫ㣫qż7E="rX'ɐs0xy~(-)=ĥ6*n*S@ޙyYVСiUS3u4Y)L70 <'F<n|H}:6.*_!޳{:mG[;ϧroeK2]x9N)g"1ڱC=Kِ{e4n4}:OtɻWܽ{!'*V!:e
"RHlcqG2gB=V +^7AZ5E<H@p%{bgL?U{6wEg4uV:;Zr@KȜA!Ax'}`]ڡRDwLj:Ȑsg-++H‰REQ(ek	Ea@Iiަe"Fys@[}0Q	
h4"9UHrP,JƖ@ >gS-MEShY\>
nZSGyjwRzNت[IYNr^=XҸʻ}0`2žMD+hYG`^YZPn	iTCjL[4
sJ4}eƙ0b|h
X]"<
,MQm",FggK|AL_>q}r_sʧFN# p|~jyKcj¾E3Y3ec꓃m忀p74m+hyu>S=_r_Euk[p׻`YReδ}׵J!ɲ6Xy`GWҞQ)ee [-|9U]7LfYAv93Dҏ
oIP0~"r,#j!OOpZ?@{~98G&
BU%GX%7N.zl[II\s%_RGK"m<}E_V>x}(\z#\hn8$a[47H+1GkU	먎:}&Ps&hq~/qlE?tw?ۀbj`W8OPpma)r$K`RiH@	۞cg,Tt]QJRp8UdW {RKq#dj/`dspx?7+X_8DM3D?[hY/ނ[x9~_gW>k -'l8>aq]/سU|B\uGO'$~+9L,X8J#G&An˧NJAB2f째hyK>b'>>I>vw3dRPKKc7PKnLargonaut/JsonDecimal$.classUkOQ=--W_ "|Ђ"RXܖ+,nwvۨȯ<Hbf2ݮPdtggΜ93~2sk4xNMcYG07r_CxPެXE9T2a͠k[v`6.UG
ɓ^WCױsӍ(]{det.9t9S:IW#cp'UKX 
%7B=3H:a!B]XsΐDDN3%:zB
Xt=Uw0Iօp`Y@ERbB	_d+ߔŜ]FjLMT>Xrl;ɎBqdLn>ÊPK%]PKnLargonaut/JsonParser.classXW˖ꢩ+4KQE"B4QDz?3M LooRwk-?iߘ]+Լ? 	`|.'Ekkfkky=?3]rB#T}hF?WD{(n'TJӃ$q=%m>6;R0DD؄||lBhc:p"0aRȴ,.t[*Cj?)&	6PSm,hX[.7v{7ULTdgkk(X0z"oB|#&uD@: hv-۔Y}-
әiVH0J_v(-Y(fxT֕3j5%7q9 Zk
	u4J&8^wr6	^Qr_(SJ¢+JyϋOFvua(DR+JYM#ZĹ$QNJ[σAW-m6cJ{t̽FZv*[XC8A/۶NLvB󆚑؞kL1A(J1LZ'Γ_>;Yp?rx>9k %(l	l9҃I4x|^+_v?:I+euq8́/8 kO'Pۄ\aA8ҘTH*^;9+2EP͵)~]Has:!Di5 Jj~Jjo7^|9n)N!+##B.:6Kע""ŤD7A(f0T(N	-aZ'gcMSb+ׁ^g
qAW6lUOg"DМJuvRf(m*7%s^Wo4J^'O;+\7plW+0u#t!W95iU#T>: fI%*rخJ,ITpw@VIWb`!o'J̰H`ɏ2&cs &Ô	/@^Ò\0M.#;Ĵ@v^tn O\>Q`O
'iE?@J?ߨ~e1T~{8LO]YW\#.c$=ʷzVPFa}I5GHb5)Q)I'xeUJwTްmcPo8YFk-qC7jDu6gnW@ˮʗMh[SK@z,ǼSцǀm$>6,ubtM`5|1`2}7%,s?aO٠lOFv{>R3SՐ'ViNUCD(l
=Js[QE4蔷7A᾽Ԁ=]Xg/J
fn
YNhasMg%Q]d5U01w^7QmH\DžȆWiIm!	X jXvtp̬^Ů,[W/.{5Zu+Z :1"q0=7lGN$~Eȴ.	yA9[ZIIBZIn`L'eK`0SR͢'1@FkaS7r*#A
;	CI8|X"\j2<ɩ=Y]@4^<<7daU0ޣZܗY4PMF%X*ǢcW`&PlfI^waFDI҉EOO8BpٲD?l2$ToP2yX2y8Fv/B-`ߺgv4G%iN&vD{,W-ߎ
:AlVNlOrryT	˨?5v
DK8xۤFH2:SppWPz]W̃>瓾'}y@GznzuFmz;Q+
9k̓d+M!d,%	X!	}1
By.0^j~yшi^}4/6Zs(% xlcq;\ db&XOOAy/SdE1y@}_X|a(q}9\ԇ|D+3-(S繳RU^gӞLw+|Ψ0kXﺸhό6V-W|rݞ_1$=о<Ϡkj:$9x,\;	0zkdc,!g39Om62|6$:\_C@Att@vG0Geׁ>avnus'KFgut#Ͳ\-lopmb#Kx	.׸=@?^|ρz]W_縟U[m
Zw} (ûf+nnZwƵ͠mvuAgFQч##@!y:W	:3ɿ0%Ǟ0=^D¿6.N~۸0}*P PK
TE
PKnLargonaut/JsonNumber$.classWkWT~\8Hx$(`XAZESΜ39c$5i{WeobLK>Cctյ]&A'%8{}៟^GMzaѶ>]ܜQhAD7tVӓs׌bŌB#GZƫi;&P7/S0E
2J
EcY 6L3Nfii΀?W4^QQ1bd̜H&Gfoْ!мiSEΚvW;A
vтTٛ.4o8KfQ@[(عuWUr5wL"i9dCG%ƪ`KP|Azy2,G.'XqI,)wPw5BZ`,57XQlƋxN52&$jV^HG2e^ؾM'~6W,cgk6se
OdΕGscNΚZ`Vp Q.^R5ܺwxC@*!h+hlE].j{;?Uhm+c}w.>q
^|*ym
gar
paۥg-~e0feZU7~
9%%"(am]a^q!1zq-b
{4:@v	x	5[OJ}2w=9JS
DE߆'q_zxn܆Lևo2XhJ{c{䰊0{7dDC}hէ=NPTa[H//fKiE?D#D}̯N6Rw>b㧫=죲(D)'yic*vh
71Ʀ}M`81w+p=P0e0=0CHf:Q&S,"CS\Z⒴Пv$PPPQqێ82a'%Zw_٢x¢EVo"qkÄ228)8V^~b3 7@l}E!PW:@du-=pṸ0"4qʴ`s@&$kn.4!X7K3PoHYSpo3,'uUI[22

RZ`{ !~`=3b-N(=2>vJ!2=$.bNKU87!{
5.(˖({EEe̐ž+aB=|=/,PojIb!~7|?Մ
?{_>Uje._=3x'lY[DyGoZu:?r%uB6/!$dS
@" ',p+D`Ur_PK>oPKnL%argonaut/CursorOpDeleteGoFirst$.classT]OI=5L; +*3~
f!$VC6/V7&VQL0usϽ՟>0UK<ҥH,@h@.3`ǜ* 03N<'8Xs}=ϐ,z29	b8d3j%6ùBीҪV~*"t,Rzo3}*C34P=_x.k;հ):H7d6ەNCh_g`(((-Ȏh?5Zdِ5Y
h	0tTg/1.CT{1^Wpp\u030Jϥ^Bq-%vwCAٔn#GZ5+Nlz0-LQ\3,8S>P%
mgăX~gʚEſ>2R7^x F&GД7s@Dxmo,ޒ65̭HI5;fVebٷ'Zѫ!],Q
7%CZ0CSLEYz,ɼGbvAafip"NoܣqbIHE&F 
agFc;\~k>na?hL=C?
(:YC
'b6WgVwwsVD$^ŘI~W@_u{{	v7(cS]cbs1\$WK40Ӝir.
af6cFAPK6CPKnLargonaut/HCursors.class5QKAϝuv[*HB!Z0QFYghg6GEՅs=Ebi(]r?,k
{+&\e2E?E.vI
=L6nZ};i	!),\;䭘߸vB1
X-hvTLAy'5/zx,`Q_w	)U$KZNU\6N8eܦt9CCUAw; ^E
pPKzMCPKnLargonaut/Contexts$$anon$2.classkAǿM6Vkն$E!!/B J!M]ۃY
8{9Ј9؝~fvn xiHm84FU]E;B(R-oLMɹUFjJE2:㻈kpBo7\Fr%
y5{j(A(k7Mdh»3SF&2&o۝QCB\BmZ4\,
gX9'7ct5qlo,D,V'&R^ydk!i-a$D1qG:FᷔE_wq1{ }̑=b[~%<[S,rcNk~b[d[Qw_oI띜VxLX{K>D){/|\Y,|D0<_3i!}Z~B\$M1J_DG+w<,[FHEV/
+bê㺧n ZW4S۰o~N,mې$;D~t5 %oA
˶os-Sb$jפlj@ok|s)ҕW:$t5k+,u($k*S'sK&_o	`c3L+h~4+`"͐`d<trSP% Dvqɮq١˨%6 :6b[@v'60.23tTXV)x%pٳNuN$\xMLeeU}csk.hzn1'K< TVR	6Ǹ~r\ԁ\
؎N	j:D&z\.z(!|A	7G:ȾTT-+5o(s.>R+Ȩ+4%H)r9\4e4]F6NTWLR/hgm[%}V#ef2w&'VᩤPKc0)PKnLargonaut/Argonaut$.class]|@P%ƦȎ(2-+D$+Ȏ+츭D[$:iܽnݦ{RgW+]iwwJT;w?,Ip,8ھL.dY<|9{|j\"eiys,-`a<7yzxV2LdOM<,dR,ofztTVJ̍/+Mɍwߴ{=(r*͇&FOī]gdi^޸q<7:eMO
nU^Pvg%7NLgG'9Yܼwԙ<
ƥc崺s'4%Kk-nx3홞MX+ZY_~x|dZ_؀mbz|jd,}w	Z5t Zoq)<=520ZM&j41-bhniqt?[qTng}f
IfQN7`džNm/3#E{1A;zvmSÈ++Q
X+6{2;AByarc+NیYRvVl%[L9)Yհ)]G:TQZ>K.9>:B<m=BfHU"]M7z`ӄu1{04"O8?0{,WO"1^e;
!N!"%=*:	ГYCnsIdF!TsfYVB&<Ȩ?'!l78FD=1~MD6M
	D9ʸT*}[ҷobZ	pE`;<5ƥ\4&&rcXŷZ#ҔQ4\3=v,;FU$>N*fH =TzD~Hm2ѺC~,`?瀗zlh=O,~G#lܚ{I]Cm#uev<;1<=_ik"PhW
6o?$A^_79W;Ԟھ?fJ(y4Sf ?a$ZҊڣfrL"((}ϣ.㛲{[7AO!}YbZbmi%4ϖ(<'I#|6e
fyVDcSyCȐ?ACfj݋Xn9&ɛdɢYPL?bd%KҒ	#'-YR,Y>kɒd~Kݒbe#W,Y2,ݯYa8EFXXЍStod%8EFXd闥[T'=vDKWT_[ IUo-B$t8jRuy#(|83ʄ(*Az	4j͕Q5-ah9Qן'}(!E%Q–^,S*tI)ʤ 1&P(J%\@g<]ct

RnFr<DX7#Ȥ5ЯB"NXo:r
4';@@#:;MYQ~:$QPWǰ5Ѱeછ;YQtF7[!"Ν1Mܬ$N*S4N[$A1"N&nV?Vf+E;㞸Y4>Ln.;9=:%Kb:FU,E0V"QӤadŷH!P!]_4~tx|]o_5x5CwAHoE
榏fQ[w#
#yEwHD?E$O?aW$/̿":b!cd-{)
|d>REb,E
(p+idlxZh-6)7ihvU{ȿ"&95 kdݼlZ#!	l^Y|3
,`'HPQbcG[;Ⱦh3[*jZ-Zgd_Oub&)(t>)ZmRpQ"AԦ)EޑS]qŏ]Y\->khK(FJ|çO@DCKihK0F.7^QTWk-l%B*	*G|їeMdN /,vz(ЬXR)t"z,ݡ=Uy|SV|;|<)/K.oogKcyy>lfL ڬCRG~pCB7Pޘnjݯ׌u1Hdx
DyJ{kAV$Zey邦/Ό(gƁ3Vwr"DFDڸ])ʮi`zʍ9.(矇	=aC9yX9ǀ蝕| gc(c/ǁ͢<$h<~RɔOn[_	ns@xWU~{3CϢ哢m8
] F	=?_^: ?Lt[%SzYg	=:=$?[Yt74%%[Po:ׄ^KZ'؁Qe1,1'cyIcM[ho}+,XδnS.s]o:wAΆ_Vo}/ЛN}Sh/XP7K-5*b+>(7閥8޲|UTz"O>MLA8G?"/HRAGDyFH!"NĎNG'<2tT$N߷YtJrtJS|5	$S:%-:8:)UN~N)NiNtJ"B:ɮSڢI/O'|5	-w?:22)C'_MEBB:ϮSؾ)Ea˟VPQ~c"^j:k(SX.G1AP(mU,S J]M[Q,nU,SKڤnQ,aUL)sti(o|R6sӬ%ybbr7P1VbIb)b>X4Nu;UXʪX(.G1
5bibib:O1#PL/G1cG*v9G1ݪXa()G1uKQ:F2GrFԫbv֑G793XDV*vuA}"ؓ,/eyE]?˨KJ+]!?F,WU+EnϳL$f89a>+qcƑ'q=ziJ|%;WоJ˄7r&{vI`0.!@?4	%PgKΖ]}*J`X*a2ZG	ڝqo:Ś]4~`ObGx"<,BR	848484848484844,ҰTI,UKRkL"ԏ0#h)w9M@v4Lw]ߺ
	dm41c8%qJ0a(PC)R8ppLaRX*JaRX4*mPVV)h,NQtV%'sˡ弽Fq'x\Y7=4ji8qPK㠖A-Z55ZKct,ұT:JRXu~)Ɲu|)?9jG$oWʠ1l	{M:Cd"38Dfp!Kuq.1%8^JLK_b-;N?Z
sm:B'nzZS&}9shxOfuq4ךZ8^kkMxi5㵦q4,*E8^ˢxYT/eQq,*EWq@elνx>>b=;!h\\w0qs6xpq~8/Niq8-8^NjxqZ/Niq8-8^NjxqZܺ8-N	Y`q#;ʎ:xZ,%LOL&&r'n1{*#ំI粴	vN{Gc)n5$diY"j
[Y\TT3$ɩi=e@N糋;slCOQ&'d5X9">g	#O*ӿdi5b቉3{rSۉbيIk* AtjޘSU;딆:.DZ9{|
В,GH\AK%uK
SM%<ͲX}dllzjhv{?'B"{K#Db*@TnE]nyJR;u^PdsȚ{{hhQ>)Kq
d!%FAg]H]c]SC
y8P.n$@MaLnrUm%o 2Ld܄P]ȰDZ.hC*!0LD*j?R	H^#OȤ,7k,U"s1,1vx#dCE`*uD׉)eH].M;iY>yc;ot뼂5ӡ]F;J#HŀY\p`>*+)NCPhtp8Pӛw8Y%x&ʴ]8+A?rGW:0ŶֵzX\nrN'sUW_'{MAdvx'.
.8tЂ"g
tpus?=.w]9=x30N8#sT_T $^9#rV5 %H@:3 Wf9"u7
`v&;x-Dy
	w*re$
 &ЇxL~)z8I|`EG9!x֍=;%;\iE΅![wÛ#ȿ8>/#ȿ8>/#ȿ8>/#ȿ8>/T&sTj>GEƒ
*r.#=#NbWxF"r!q|HdLJD!q|HdLJD!q|HdLJD!q|HdLJD!
r\q|.Wr\q|.W˕r%\	|.W˕r%\	z.9L!M^Dx9EN[Fo.چD-ީ"
s>4 Mt>-OiKS>-OiKS>-OiKS>-OiKS>-OiKSDKIg>|&Ig>|&IgZᝫN9K.S䜽M߁tFVj@~HxF$rax}t>/OKt>/OKtDK%$^xYB/KHe		,!%$^xYB/KHe		,!%$DKg	x g	x g	x g	tgCsEH9E Ȓ뗄ᘯ.YvFBٽDN39K?	#$^?xG/H	#$^?xG/H	#hxhxhxh])|Ɨ:RY
ϊhxVDó"𬈆gE4<+Y
ϊhqx`w%>OV[SKa#rb݉DNsa,e6^fe6^fe6^fe6^fe6^fe6^fe6^fe6^fe6^fe6^fe6³@,g4<Y 
ixHó@,g4<Y 
ixHó@,%IncAS#O9FNG%#qxa#bsENs,3ix93ix93ix93ix93ix93ix93ix93ix93ig
zixKó^𬗆g47#-#s`iSEXxR86plJؔ±)cS
ǦM)R86plJؔ±)_pIᰓa'N
;)vR8pIG#ۖ>	,erupb:[}ãR?;3;=uƪ=KTjUvi{"RֈHmHFꒈfGHF*:T2"]bHe"v#E2REn#uEDJ])iDFʈ1R##uUDH]0R#.#umDcEF,uT-d1.b	LwW\a	L1h㷝{}ӛ>6-.^hhnئv2m%JhӟPBCr~}fʦD#cã>&98aK԰%:'C	p٠(D`Ȟ$,arV[Vvg]~{^R%^JhSd:B
V`2zJBƳ>,{Gcq:ѲlɄMg|lCO8RA[6H:oy6ΥwisANH:-C޺īKwfJGc|r/KgMP-\@\a[pt_{sS8
DŽϨ{G)/%?*2)	KYW7/J`]MI8݋":R:|S_d
X?~`)M	=}DR=Z\p炶×+lˌX޷,EH)yj	9b`O_KWuV,w9|icaovX_e/M2*ue…	2a-z)vҹ4Aʫו#;Gf#KESvծ9,3GqX>\Q,4e	^#VZ g}+,09,5[ZXW.gU~
3W~HFY sh/jyjU52v:s.5'(]$jbt"ʃnt^
knWП7{8Bvo5ƨ`-0&u^X:$PƮҺ@MsW<_feIh;WU=By2hL\tʕ_0իA෧oݘtA3좋E8ov/3K;D/^}D?	/Zw5`FVC#o/D_
^/raX$$#+u$sAWzxL}^YEs`\BhÝWw6Gl>d
;ը|Rq=<}40׹\'Lzps@мB#"_2_<[nͭ-;kky&µ>5A"/Χ.Gh^#ܲre'G҃Jwdnodr*7qT6f$59xw	Hv+ozjdtޑS	]`q<@Al˷y45_]_!KvɎ=VyW~;0>-o.+!G+þZJ2ύf2Ofdz#Ƿ==2zbDn,Xv5S4]-a`t#ccSF	[#Nnbn$=";'63vdܯ<8
{ܺēE!O:-+c#W4'ғcO
srYpzW4.BNS7@r4+o(	;sLA`7=[Wlk[ރqSJ0+\00˳7sx"o7+y|f(V3yGZj+:dfY?=tW]lsGJay>=Ů&8Q!'xS*xR֚UT){=+[
[xpTJ$d٦+n<#&rqE~U2BWgoʖy|++0xc+[Fn%_7;ۇKD^y{ݵۜ-Z3`If=+Ül}+&v
m/Χ$^M^uP{|8Ģ\?c?@
Zaa8a
S݂G8@;)/Χ}͂//3js58$cxn7As2pUq>tNt~4Po-sL?}sG8lq>puwp嵵Jb#|>id>Ayq<7:edɩB=S{Gc)\q[~7BptwwKU,q$%uG-38{%z"`\*PW
=Dkqhj[8FyٷT *jDtIDN2{1e^і,Ahy@Wn"։'~e(*1z EyT KEtUD]e,:H A{B-+kCjE[Dʢ7EGvG{Ey?@fX@@ ~N(01hI5vG>C>裂2EX$μU8ȼw4c2n4*'rLdtN8I&D*{\jp#)d&^&D4PDڋ2Դ)&^`&[EVDme?i}ԓx[2V~"h.Ds~Orcmx$b Fb F?Z)d'=b-0}oQs#PwhDFhDF*˔S*8#R^Ah>266=5|l4drVbY+(l=R@kS' hXl+dԶڷgzb27rǝrNLOeݞ=qx|dʽ	4VS#r~lx#'IeE:?Y4a^:$DY9MLyxWwra95<1||
r%:J-МfO8dw[#n٭LV7PfvUuZOe{	No+=Ow7ax|/	D3[&]<Ϳd~+i	-V\(7=q#=G۪<Fz{w	PeG`Fz{Oqi-33ܫ|&7㪟%=&-U*ϯET`<˿̽ʗWy'raR)T~]~ou$q1~#myҾ˭ʻws}kXkJ$ْm3u%č܏չD!+6)̰>$}'݄[W兿UI>.qq՟>ǫ+nU"Uê*oS;pWr?\wU߉#j_qǴn	I)VޕI+?a-R߹kfK8|K&:ןʁ=?;/7%\qPy%ΒVZ.BS}hj)4hQ8ΰFAhò"̆0OiMꌼдfMCt4M*I!DŽXZ  zSSP7bWD
D(%DQXτZ.E啦`SĦKȿ5
hA rm9VTG0!xBʫFSG,%F6-7DDQ5
FA(5De&ZLK&LFaVȭч̧@U *}
D_2DgZQCL)A
SE.LE^HC=w
ViٌMFPe
TYUր*k@5CBR8J})uRJ
b%bۊuŊ5j\:PmT[ցj@u:C59J͔ZEIR	U4!kw/!6mj3UbUAFPTmUAFPTmUAFCU/98J)}IWIETK#IMygA9A
P}To7@
P}:KTG? (&!z9Dy3(a(fh(fh(fh6`)<(c$
'7:yo79Ӵ|F&f@	lh64M&f@	l2a$HD*@Lp8JmqiŌ|իU@PT-U@PT-U@PT-U@b@Rג
h`]\dFR>"_o;i%O6
н(m6tfn3@m6tfn3@ـT'H*@>P~	?$ٴrF>^=Fl([Vl([Vl([Vl([VJVr@uJA%
P`OYXRj$iՌ|sڏ6
mh6
mh6
mh6
mh6ZVq@4yjL@"@Gx
>V3eBsF9:P@cu1:P@cu1:PYjVs@4D'M?Ij|Ӛ_7J};@з};@з};@з};@з};@n@RS$c2#\F QCb"F֑f:il`QLSt):`0ELSt):`0ELSt):SCIj-(cF9F!
Rҧ*k>*k{qh鋕}{K_rh髕{K_sh雕C{Krh黕#{Ksh釕c{K?rh駕{K?ΟoeZ*B9LI柚ͬ_P7oy-si^wfh<"4/M3og4/	D
޵p= \!)6{dLL6{ӟVH!JO:e_¯׀ktdjIGtdj97sұX!R$+"{S\@FPkAFE!)6dsqLM64T)?Gxsq4x
fzK\@fPoAfPYYFRl
l
`LAQ)(
1EJySP2!:&,WVYQָ̬8-N8-NӢDIͬ0
ͬ0UϬP
1By3+6gVSΠ+,:.^+
x^+
xzbF6!`dFcB@
R~BhLP	7!p9!P
P"Pəlfn17pcnLDR=5f0f=*S7Hԫ{j
lxc8"ףVף~w~w~ߡ\LR(3{=^23GU)zAʿ]%_6IףQj(}{=[Wa=Iô+L$Ѳ4h`?8]`.0Ntq8]`.0NK i.f,u4N3SLt13b&8]LkXi-KQ3c)bv=`c{z?#H&VJ1\ScSӌuF`<
40xOi`<
40ӔId9kOcf\RLǐ+Y4̸LǐkYjiF(Y:!B}ʕ&1^!Q$ight_ n> N N N N N N N N N N N N N N N NLҳ&9v2bs&9v2a;MֱTI&,$NF
,4ɱѤ(M6&pGF_P	a-.#ĹZ$Ό'IPkh5K3hL2g& Wr\}@> Wr\}@>Ibҟ5hΙc4[R
&Y$WbѬ&6\}f-,Eiv!KQmf)D"A8GŤ3Vt*PLZj#IR5t2\ #|@~ _?|@~ _?|@~ _@Z8kp-K3hL36TI~FYjI~FÍ,4hxK1hx!K]k"4le)Rb!2BqqI
)1ALQE̦-3Ja79F@ s9r9@ s9r9@ s9 5L&9Mױ9,`stK5`4mf-&9M7T$iK19h59hRiKu[8#˶TXA(v*JNj)ִuF:
  w;y@A  w;y@A  w;*tL&y׳9M,`w|j2;hd4&y/d=&y/bkM2_R7d4R1BrWFn6[KjcErZ$vA&vS{Ӷ~ Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q Qe1-Ϛ>hRLre4R
&27TIXjI-,4}|3K1}Ѽ5}Ѽn0}8ۺ1GyJ^b'c#v2xz^ovZys*o
öl4c}F79TNn%^H%Uf\22O0R
RRJw+	88h3']0sZU_˩:/S
_L0Jr|[WTn%?WO_%Vk˭w*=?OJ⽒r+JJɭ?9ǫ$$$$s+QWRO*	s+Y꽒R2n%Cq+z̅Mԥ$63FCpl;,
kj;,Bt4K")
Bv1At&TXaD(%bR}$XPꐹb>"D[-іAd2t	::P0lFDQ5
FAԨ!*Ks`~#$t!sqPaҾ"
D_W@U,@pâ2E)dgTYUր*k@5C:AR͏J):	7wa1Tցj@u:PmT[gRgņ^-CCz+dU6j#6j#hR$aUWCL̷%wXށwX7@
P}To7YIqvXla!m{[ҟ,>o(fh(fh(fـERZbB=Abhl;,4M&f@	lh64M&f
K=8;,6\hXHR
BO`Ȳ;@jZjZjZŀAR6$;,,`vX6tfn3@m6tfn3@ـ )
;,V"K|Pze+@
Pe+@
Pe+@
Pe+@
PPKIAeCAe(Jbhm;,mm@жmm@жmm@жmm@жвԫIb4B~Ce}lcr1:P@cu1:P@cuPԛHjCj@'
QK*oлvXvovovovovzzIqvXlbXM#ƨ!zoٟ,>!St):`0ELSt):`0ELSt):)Xj87Om;(yQY;,,vXti:4`N0M'L	ti:4`N0M'L	ti:4`N4,u7IqvXlj8F
B}+bཽmWD'-}.t/l-myWB_侃U[%Z갷w-h{K?
[E:-2=)[~W~?tDK]+-u[w?Tɵ%U.R֒!nKK[ZZej=-(ђfo)䶴ֽu%ZJ[Z6r[jvoicR6p[Ƚ--]rgTDҶ-:K-u/RRBո--eJtKܖpoigv[ڥ涴Ͻ+KcoOmj)eܖ[:\-QJt38|j9g
yg*Q=fy[\yaaQGԓwW~'VbQR
6ΞS.0*â:nܣjGtw~'ǤZOtT26;,6_n>uQϘOkԇHI=IQRYT%P>\j9
ھb~XMǘ55ǙT%\\o~Et9i JJ(*5O62'gK)+IsQP4%GIQ/5ZNﰘnWiE&8-LpZന/1iQ_j>l/3[ԗK}] ƣ(i0JF(j5'Ի\&	;,5kU_gתU}	^FVM曊V曊V-B%tQD(i>J&(i&JCSwYaQ}	nL}	nL}	nL}	nL}	nL13_b${D(&JĈ(i4J(Q?ZQK.G9rNvXT?=~G___{oo}3Y/R5vXƵﰘտտտsququԸ4a8;,6wX,CRP%JDQ"xU9_?)JĉAu%RvX7oa1N/P;,	/37n0	g'4~Oxip4~Oxi*=,$ae(%EbQR(%jDQ"z%FQ"b%bE@Ka1\؂b5l@wX7hcgxILr$f;n5ɱ3|I6;[Lr(9Xj+I$a~N5D(Q-JuD(Q!JD(5JD0J.;,{ﰘ&yzqh/<`/|Iu&‡LrMrSr]|vX_OR;,Vpt3
D4L=~w]EG9@%בCo&xCJbx@>a1 |Lo46>f?|$_Ip$_&|&/ھﭪ	!lcaaG
Mb3hhfI5[xMD6~
".[ߩ$r'OҧyϚsLLf&f&f&
Po|JiJ'u	2H`"B@|
(M @ /xl{<:9&Z7,&o/aqH?Xd.sVҢqJqJqJNqJNqJNqJ4Y4Y)4Yɩ4Yi4Y4YI9+99+9RnRgʹaqҞ7,N0H`` ] @\	$E 
hi߰Sm
io%[IO$x+4Jo%[I.Vx+e4Jr9\A$V+i4Jr\Wk@
ɵrnX
l~-@&K 4Pp@ ^ @`!	$F $תa_7,&_o/aq5xbr#{vq&4'iܳiܳ[hܳOѸg'Ҹg'qNnqN>C㞝N㞝|=;=;G㞝|=;<{vϽ6PꋠNP97,Nް_(	@%J,@P@/\ @X	#גd~q
Ni#=4444^Hr$?|?<@IMICIKI$ߣ$ߧ$?$GG7,&KoXLW
6zRr")P6` 	#DB*Q @,@1~<z	O1\ƒ?<|&Y[6y_WV9؞乼ya$}9ߓ~UgKŗgn^"?4I}
=x
e_/N^,_ν^hQxt@%]>]%{!o9tEP^Dn/Wu^/>BEh,jBtE\Z5'Ǜolt`}dYJGݷO־ȼYfB^9tt1-9%3%3%m&\m!폜R:.KQ/iü·/B/=|tŸ!p5ЩAAAA~TJgD7OBtn}Tm,JzY6]Pe
yhS}ymjtK7[tg\tZkZkZkZkZ#qi-B[eipZ銈mJWF|p0vUqy`jꅋn5[s8zġ/x}>-ut=O[ut#O[utO[ut[}c q>AQH}C7HGk&Cm*}ޯ}s݆h7mȺޯ}s݆oD|m݆{#V
YG|6}5d@C֢-7nAq;;Qq%k^:X\B@P@P@P@P@P@P@P@P߀ʫo}zӀv-C[VћcNz4s)i@;VPtk%~u0]Sz,^Y?](9E$<j܂wKG_x}:[ݧg`P`P`P`P`P`P`P`P`PwcGtJjǜjǜ锞jǜ锞j锞j锞j^&Tm>
KtJ&Tmy}:c1m`~NmaLwa|lpZy[.`Cy(P0`C[06?jPߑsZsO
`````````````k=NhYN=NhYN=N`h'O@FˊvtO0ZV{j}eE;yև2ZV{j}8eE:s-+ֱR1ZV{j=>1=>){{j}r&#=ZǘŒ-N{hC9Ιoww)w5TyWyWyWyWyWyWyWyWyWyWyWyWyWyWϛw59Ѹ;:Ѹ;+(uqU{wVR,FLQ|F㪶lԅUmXMڲ1U0WecM.e4jJ]h\ՖiJ]h\ՖJ
0UQhjUkѪڲ1#Wuƒ/>oHN#Ԣ~:ݨwyou;PD-C-C-C-C-C-C-C-C-C-C-C-C-C-C-CMϴ;ԒkMo&F6e'kڔR0״)W[kڔR1״)cungiSJh_Ӧ}M2Q5mXW;kzR0|}>aRIv-3*	7Rʟo,ܹ:n,֎qHG,ۉ6ß(/Mݤwy}}a,ܧܧܧܧܧܧܧܧܧܧܧܧܧܧܧܧ-!}&umXA0Եb%d6klRUz٤)#f6_LUafzd6G1ӣM1&Xfz:٤Mq&xfzzI==٤lRO}y5C)_^m/6Rgލ_)y7QgMsu\:2*R>p`	`$F,U whw{οHwwkAFpFpFpFpFpFpFpFpFpFpFpFpFpFpFpFpFpv`-|U#}U#=٪lHgj0[5EVbfFfFz	U#٪~٪^lH/gjW0[51[5+釙UVjfFz
U#٪^lH?lH?lHJ~&JlR>o+9x:C[L3^.M0JGJAp@,WP	@&K 4Pp@ ^ zKzk[^
ߊƟ(j\;лeVҟwlQfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpfpϦ6HOa3a3ٰ~ٰlL161636/06/26;
闘
闙
W
W
ט
]̆nffza3:a3a3&a3ٰlLg6lb6l06o3606S_%l6SW	+嫄-U€RJR)_%ljt^߈	u
)P@y	&P@I#P@5 ^n
`*R>p`	`$F{Gi3:AȽ[nӻlJcmemcmgm3۶cmO0۶'m[m[m[韘m[S̶ifVgfVm+}ٶ>lJlJgmem/0۶RzRz@)zRz+O궵R u
ݶ9>Gm'}5,P@
)P@	&P@U%	#P@%e Pz@ +UJ	 %I(8@1'گn׻<|ou&;u8fa6oImyۼټme6o30rm3ټmg6ofEfYټmVf6o)ml60ͪmy۬l6Sf
fYټmb6offl62tfYټmg6o
@o𻭕mԆݶJm
*1~R58<~$(^rj(XZR(RBj(L*(F2j(@t*TD|	$H}0Pl
Ou^@ѻC;3t)Np	E'N.:!\tBp	E'N.:!\tBp	E'Ncd17t֬:f􆔎ٖBnjސ1۱ZR:fV#ىBZ蘝Y-t.:fWVy#f1ob1of1oa13Y-t:jc`1X-t[Y-t̞:f/VSa1oc1{Z}X-tlVvVSՂRwJw)~RJCr!>NK+.  0\l
VT:P<
J$zD
@/]hp
@)Q8d0s3DOet`ݹwy3'%#Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/Y/_Yd V#j$3!F2`5CYd0V#9Hf`5#Ydj$3GѬF2sj$3sYdj$3DZF2s̜j$3'LHfNf5SXdTV#9HfNg5̜j$3gYF2s6̼Hf2V#9HfJM;*7ewRo)7ewVo||ei?\
sD!W9
C:#|:
hcŚ:DX'cu*iXcu:, '*TD|	EL{|0ԡ7IM3u	>;uh>2SB"o𰗘:;# ԡYe0uh>quqt|<ԡ+MC|L,ԡR:46NOG:4:48uh
:uh>q 7SzRe|:4\S拴iNZ4%Z4S+W#NE:4&s:4wG:4�uZcgEk3̷i}_ӠSA"NMND:4<%x B/|˼"^©CWdo~Jk7?/hZ{%*ԡuĩCשC{\ͣ{!Sԡ?zӀy4`7
?ЛMOilհO2[5V
'f}٪afj?3[53V
,U>lհaj癭V
U٪alհ`j2[5\lp1Uԡ:uN:Sԡ:u{IKaj(L*(F2j(@t*TD|	$H -^O^SnYfæ{=a	a-lt
nyfæ[ٰVd6l
nefælt̆M
aӭlt16̆M7ٰ`6l5
n-fæ[ٰa6lĭM.aMg6l
n}fæۀٰ

݌SnÈSowԡ:uvN:ݝ7u^JSP@
'P@aU	$P@1!P@-XV( 
'L&@h!@ w-^%SUSnܤFMZnܤFMZnܤFMZnܤFMZnܤFMZnܤFMZnܤvfm]m[nWfۖۍٶlr̶-&fۖ{3m˽ٶf2۶̶-Wfm=m[nm˽ٶdmm[lr~^߲שCu-{:t~^߲שCO^SP@
*P@
'P@aU	$P@1!P@-XV( 
'L&@hCNy۽ټlva6of3݁mwya6ofk0ݡmwylvG0ݑmd6ohf;ټe6omb6oxf;ټNd6oۮlv'3)mpS\ԡ;:uεN:sS\ԡ;yS,C_xXušu0
C:#XGauֱXsZXau։X'aN:TӰN`u&Y(yNyS}:\Vw;B]j.dqgqZ踋Y-tX-t%:RVAVwB]j>jdqfqWZ踫Y-t5:ZVw(Bjndqgq7ZOZOZ踛Y-taשCwuv:t~]aשCwwTM2L,!0/P@e,P@
)P@	&P@U%	#P@%e Pz@ +UJ	 %I,{N0u>j$s_`5/ܝF2%V#2}Hj$s_c5XdnV#Hj$s`5oܽF2wj$sb5Xd۬F2V#.=j$sc5Xd!V#!H~j$sOXdF23V#9HIN:SΟ쨔?	I)SηԡmySLS0LD`F P@-P@
*P@
'P@aU	$P@1!P@-XV( 
'LDsy"^wO]=,gY.^ϸer?>}Lvp|1o}i$'"_=\O%`Ygqe{/F'O#}wc0t|.3s,3v&+2YvLO]%ÓUs?>ZWۇW}xjWӇ{VY-#zE{=L}joﱋf\jZ{Yz~¬gxXg^;_}['%`9-
Kr|+-,,Y2~=ؾsڹLfӴ\&ɹiz.39?dӱ39?2|L.O3r,
slxL6e181e1$Ɏcgr!~,ؙ?mdg nd\&cgr~:ɛbm.cg].ؙ\ve2kL.;2sL>veR;ӮL;ˑK陝W-:[\p{{>aYWYo4W.z|aYtYzh<]w@wf}P>7Gf='¬g]-|ֳY7Y97,|֕qaև{[u8o׾;z껭瘾y=au2iXg`uyXb]u)XWb]uݭ"߮9eI+2n/xg8q/'Om=T(̋?-N_Dą_qtTtp\qm
_ΞZS;yjuOS[z*֞rSvZS;xηyj
O}87/.n#hX\\S?O=w?{nG{Dh))3
#xx8؊mmbxr3gpqG<+.^T8wkqq|H܈?q|\||\8>%>5.nq~
8*nG/D;w+V|c'.^,DZJmqr<%.[qtu}zj@|@x/МSfMKZiEI24$klq[#BBEY8]ߖķWY}P_UEWj6?]:ӵmt#|[9-ߖoKw÷.\'O&гpV8y4yLD=zi׍~=gУ8sϙ?-.%S+{~wF_{<zz.
b\JqɕzwK%)-~Uu\Z4%.=]s\ZZ#NĥuKddո4alǥJɮnqiҶq2v*
1qiqi8979/.Q''7ĥKג%ڃťFиqұq/ɥSRV:'.>Q|2.]R4.L\Boqҧ8)SǷy8S6/xjqeOP
poxj~OU
pxjzwn?y~7SOQ@zSsA{*~:/_
WU2yjzOXX)ojbIs\hN,\G]q5NM+\OPKM3}ΙPKnLargonaut/CursorHistorys.classTmSW~,ooٚĚԉj֌XgE֙6L;sFHIDԝٻ{ss35ĬkM[7i2i]6d!rU~#[{qHjт3Q-ReO$V%㤮MK7Izr O#K,Ve{dd)0v)4Ooz~ДBI@B<rO9*}{[C%*`ho%Mh%(e5KEMbRL|taTb	?0٬]Pr18Y̼M77	O7)X"n7H߈h+My
*0K{+ke4UE-;B}jVCJF]!xMߚ0yKF0Ȭf]5jmT2z	w5>Sp?ǀ>FݰW]q擙# bx@"fٜwv-7vtA%+6&t$sFa>)\
S
0Mr_[^aYBOqW0DŽ
b2do:#	!ꕬeim˩7c'y{,G[7Xu*\
k_@n(9>	yG(rS_eZpse¹x%PKQIPKnLargonaut/CodecJson$.class]|ق10G1M1d(>HriL2K v	!@zP!4R{/ߗ^FzJ&ً̭wog^μ}?|в{DYծX?зqpkלa@K)껮oio^~U9z9}S6)됔onkOe;ru׭W_7ڿmWov5OY&?u5_Y{9\Ug)U)]X=;T
\,g	Nq`e[Кe
.^k׭X6HV
\lg
$ߔz	)DUren5m?:\|N@ohu
xU2>֑{Y^nwWe-caQG~آc-Oi[1r
?aogN[Ks:ƻo
Ef{)Ee5+SQMy[F[Y<}J-6ֻ{y)
S(>ES,>	ۇ;weޝqȸI"((vldFg>ET}_|狈E"|q8_D\D\wÖE\#Zh&7>Z&ZCnn`@dK`(-Cfͷ6X	l AHEh'[26E+a0@@ L &)))+D_
/3meȔ5cΜ	FQ#@H j$5DcїX%}E_bїX%})"e_v֣h<
vet\-F#gqU;ˋˋˋˋˋˋˋˋїc ?P~X~J(ܵHYgg\sNP8Zl<2KL5vDrI(P:$tHB鐄!	CJ$I(9_ʗe|+_ʗe|+_*/{JV_;@Bp$;s9@B#+g8n%l<2Kcȷ*7/,/,/,/,/,/,/,DH"$WU {^WU {U*^d
W٫U)-f\DegZW@ZGh=2ggΨCJpL	
@@@CI$Ph(	4J
%WU({^EWU${^EWU${^EWU,{<0„!þYٙ3
HIQLI6#F%sl<2K!;s9Q2 Xw,;K%qǒcIEIEIENeWE٫UQ({%}.uy_r]ޗ\庼/}.uyԺ|4-Lc2TP5;sG@UKRǧ@H
TPCRsz6%+9Q~@2Ld݅/.|Yw˺_]—ue݅/.|Yw˺_]—ue݅/.|Yw˺?/{%|E4_.r͗h\D䪀[\exuv;szuC=;%1+$fr>.1?f1g=Ϝ(V&uƗu5e]/j|YW˺_Ɨu5e]/j|YW˺ {%+}XJ_.Vrҗ\b/+}XJ_.Vrҗ\eMoaʗ1AٙԙPLwH)0.]y04Μ^$jʺ)_MnʗuSeݔ/|Y7˺)?i\墰/}(Ea_.
rQؗ¾\墰/}(Ea_.
rQؗ¾\E\E\E\ηGHDWoa"qL1ٙٙ'_V_Iد$H+Io,qdFɏ(\|\|\|\|\|\|\|\|\|\|\|\|\|\|3`d6Fz|{e앝RRk[Hj]TR,qlH7ȴ\9eC^9eC^9eC^9eC^9eC^9eC^9eC^9eC^9eC^9eC^9eC^9eC^9eC^9eC^9\Y˕\Y˕\Y˕\Y#E$¤=Ō33g"/ηOOI)	O帗*<ΜgN0(d1I^e1I^e1I^e1I^e1I^e1I^e1I^e1I^e1I^e1I IYLb@$$@r%%+)\I	JJ WRȕ@r%%+)\I	JJG	MysQ"c܌q33g<<~B!{.;1d}xdavfvqD0d)`YȢ@h'E;,	dN vYȢ@h'E;,	dN vYȢ@h'crȕ@r(+G\9
Q Wrȕ@r(+G\9
Q Wrȕ@)p;bp2.IGf	fgfggNpt)G#0{}v7#133w3'zN>X@G8*Q,
dqT Y@G8*Q,
dqT Y@nJY WRȕ@r,+e\)JY WRȕ@r,+e\)JY WRV+eRV+eRV+eRVvxz>veY>2K3;3;sw;sG'lOydKO7oMkp@$?N9m{?;+YQub>ne=WF@2QǘdDAKdDC/Z{o?r|rojANs4wANs4wANsi/sݹ1ɹ/ȹ/ȹ/ȹ/E_ޤui9a^9a^9a^9a^9a^9a^Äm9 9z`c]9^9^9^9^9^9^EFvj%>d
sIA>sIA>sI!Ͳ K
 K
 K
 K
J9zcSF+eL_GR/R/R/R/R/R/R/R/"T@g_]>#N(qBGP>'8,%S0$CYJ~%Bo4>F	켬%ÅBpdP2\(.ʅPW(+J
%yBI^$PW(rCKQz7ZI~PK
%}BI_PW(+P2S()Jf
%3BLdP2S()Jf
%3z(/կfv^&!{(;/)Jn
%7BMPrS()Jn
%7B9gJ	%턒vBI;PN(i'J	c;ȷ-Bv^S()Jv
%;B9J	%w";HN$y'Iމ$Dw";HN$Y ";Ӊ.”cIމ$Dw";HN$y'Iމ$Dw";HN$y'Iމ$Dw"<IB$DP"I($HJ$	%
,Q0HN$y'Iމ$Dw";HN$y'Iމ$Dw"C=IB$DP"I($HJ$	%IB$DP"I($HJIƓ{)o cIމ$Dw";HN$y';$HJ$	%IB$DP"I($HJ$	%KB%ĒPbI($XJ,	%KB%ĒPEpe2N$wb;dXL,-ͲPbI($XJ,	%KB%ĒPbI($XJ,	%KB%ĒPbI($XJ,	%KB%ĒPbI(|B%Sāę.F$VИʏPbI($XJ,	%KB%ĒPbI($XJ,	%KB%ĒPbI($XJ,	%KB%ĒPbI($XJ,PbdX2E,"LK%SıgpO/Kc: ;/	%KB%ĒPbI($XJ,	%KB%%%%%%%%%%%%%JQ2EQ2EQ2EQ2EQ2EQ2EQIQZ(((((~[$$$$$$$$$$$$$$$$$$$$|(J(J(J(J(J(J(J(J(J(J(J(J(J(J(J(J(J(J(J(|8uc: ;/	(	(	(	(	(	(	(	(	(	(	(	(	(	(	(	(=))))))))))))	Sm>v'T!>w90s8s4s/%)kU{6^sy]5ΡsSe_8S;ыj}6(urꐺ;L_kk'/O6QG5]^5
ՍS׊0?SSɝkVLx͊[eӵQ0F+f&yVXjV.^rr{ls{5](H8kjn0m	o_sքלsp=57Kp;{Z{)~^spL͍'v{rȷӯ9gkL<\3{1O#S/Nk'{3oN7SIaFFb,6ӯ9wkΝ<ݥ2ϛ4lA~|2Kb= ӯ9okbܴ F͡S)|ѬŒ]2tIEkΟ7HߥiմQʟJ"PMv!+Cm^׬U#wnxLSCS]3tqc5LxAԻ2Dűil0e"n7fXo}ӯ{}3Ğ/6/i/"oX{_s\FX10EfԢIX)Ŗo{d쑱T#&02Jƹx,4ѶIX)Ѵ:㢌2viDzS5Oxœ3ڜ]x&1%fI6MrLe엱_~үdk.c31WOE'7	"n
2.5c׌]w_vMf׬#~Af#fNҥ)#ꌽ3;cckJ^SC4ƿtYTO\:D`oYveYve3!;H	t3Ep6dM;˘ocLe\6Dc[)5fؑ,Ȳ,Ȳ>үlk.f盎Rzwd;G)a3{vzd4'9oBJ	;iFf,V3?[NތSzOҬ
v4HfoJmA4`{f)dhM*ڤ_37'wF4{v,CmfLMJOpI)
J06fhNEkfe;Nf4,V؛qƳӯ|1oZJiwi73->yClC̤7/ÔqG&dl256Ifob~@[@3MLi42eܔUV[߸Wwzp3Liķ5iʸ/cÌ
36}l~Դk$ojJ#֭|oSƭflʶLM~3Mi?ɸqʸ;c36|k<)ۏ52&`)
l!l!v~~G
~SZⱭ3HdHdVd#LMO7f0ouXmk
o~Jٙ۵ggnu'4}6{1{`ߚ/軶wy_YԵ~Zߵ^~e[~cmM@mEoÆ~۾ݝ;P]7@eX_[wIeox/}•xO:9Mw/7IkզrC֭Cc-GCa݄o}2@_D
ńN\l{1_0ܱ9=7YH7t|k^nӽ\:t$tt:)8gJ_;ԞK 'BN9E$!r71_(kup:tB9Sw`B3f8-O"b݊19Uı=uT[plnu^)}{l 19ҩe/(msl.6_;_"3Efh[g5Yg'ԭsplnu<:ҭplnc{*'E9) gC΁tC΅9J+k5+opĊ훣~Gu5F]m666666ݺͺz{K[t186_8n=ѭؾx#z헢Wie߄,A.\yѐ@ʐBy<	Zk!ŪìDzlNslQW4]=Yw{Q%FKz.1]bUS`o\%:%UKXuWptk=[z[5; E7k_|ʯ@\	Y
r5
2Y$HMn=
q2j!rzш94t1G;>ߨnnnnnnn=Vz{{tvVz&{{,vzvu8@8n=Э؁<;HcX?xz*iCi@	yz
gC@yp/nbí7[[b\.w&|Ř/ޢ|1_h|1_hZ/Akn)^Z/h
Wp4+9BUMu3GS^к)^DnԭAu+[DZutv;$Ÿh;dJ}	䥐A^y䕐WAnr5B^zm۵j
|"ܾs
;4wXMG}wswbL҃444444444ގ^Nֻ8Z;;8Z;;9Z;wsvZwqv"sNN^N={hխBݺru?[pPz?[)3;!n]!@^ Alv[aǸ:
,k[;"w&[#j{ta2eܣ˸Gq.]={t2eܣ(Zuc]Ì]
O0tYd4>he}ѠzѠAYF.s]
/0tY_L@խ/ae;\ct8vn}
ǎLqj-rB>yq' |
i#@>/@ȗ _|U״#}.;a6t{)wT1UCkܩVHqnNƝ;uw6mܩ۸SqnNƝn}ѦMCFnG6֏m0t[?e~hmѦMKFnW6֯m0t[e~np#[±t8vn/lv1[l߃|!?O!?/!o!!a/b϶p\[q{зVQq~=z1cܯǸ_q~=zXBk7YF뿌f=(h֣lF0(ѬGyf=jF5ѬGh֣2yf=j/F5ѬGh֣ILűtphǎѭ8֦[رu✷ji9 _5DP
A)uAPaaL*aFa0a@:pTu:tQ1ҲJQsNؤNq׷øk	L+dܵdܵdܵdܵdܵdܵdܵdܵdܵdܵdܵdܵdܵGc጖%Ѳ`,#-K(F˒:Ѳa,6F˒:Ѳc,-Kj1eIhYRK-KDF˒:ѲNf,S-Kj)eI'h[8֦[>[y;N*b
qg~v淜0]gr	j%(J	#(2j"(R (	&0T 	#0$` jTcwZ'ecN̝I=aĽq2Zeeeeeeeeeeeeeee-ҭF:ѸjqYd4.lF:Ѹ\F:Ѹg4.UeuqY0ՅeuqY]h\V0jF*%h[dL&.֭d2J&V2xn%'8m9i9t3!]\UHPAqEPAABPAO6aIa`!*@U}V;XV	ɹSrK7H8h~&zъ5k¡ׄC	^&zM8p5k¡ׄC	^&zM8O0ѾWU{JF^ѾW]h߫fUUF^u
}`U{յIh߫60AF^ѾW]h߫h߫)	V2Dyu+wlUUb3[UGVU1fz٪>lUU`O2[UէVUUU}٪)ѥLV2%ڡ[ɔ[ɔh^)@)BJ0QW,{!	~!< CC>=J	#(2j"(R (	&%PU˪̅(o	Ϛv9j&mޛٶnl[el[cm̶ufۺ} m>ٶnl[2m>ٶnl[cۇ3E̶ufۺ}$m>ٶnl[am̶uXfۺKA	u+!t+!u+!-V2Czn%3R:l[;M03J0'G0`SD00A0NP7AKP+AUHPAqEPAABP'P;Xe5vF:so{G¿>
6YÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ:H

;d6oyÎvټalް17Nf}y^lްOg6og073vy^lްW27쳘
flްe6o17*f}ya6o27싘
f󆽚ټa
;ɍu+-V2{n%3t+ԭ,4JB[48}vR`r	f&`ZQ	$`Bf#`*!`1f z	&(br	j%(J	#(2j"(r{
Elue5wPNϝ;sxP\4/Flhhhhhhhhhhhhhhhhhhhhhk:X9[h-4+9[h8[hWqдliW9[hpд8[h9[hrдBӮqд7pд9[h9[hqдBӮsдB~*gMi-4sдBnpдB~gMz
-4gsд-4pдB~gM;)X[$en%V2I\Iu+o
>y5k r+ Cy#M7Cy+m&$`6"`a&!`'(n	*&(VB	$(>*#>5ɮCsuh'zס::|{ʮC\F#cC`סLq]v2ŭwuh'Si1C|_A.6]C:aC:eC;fջd5m;'un@j6;z?آ]ӮClEv2w\uh'szס]v2w\uh'siߵ]=Ƅ[nF
&ZQƮC}ס[6w-m[d2[:lN&C;ֻd2[:lN&v1]C:A=Ƅ[nF
b1]'{_K7.޸/{'ֻFX:taIjC'ֻFX:t]wNq!K(E+NnO1ᖄμuSv:{;۝۝}۝}boowcoowhIfC'ֻdZ:th9g۝d:mỷ`!ANK(E+NnOBmöɮCgNu:8B9)th
9Bih
c9B'C'C'׻x3tgL˧:kwbxDaN4H[BwڷCht|N'N	9Z;Ӊ9Z;"Gks*GkIC4tUs:Pu:gUs&Pu:Ttڮû&0T 	#0$` uB	%tEB"t(qC3pסsAhhhhb4r.`4rz



K
Ռ]NgKy˹gGChar3]N2i:: 0x°	&0H#00 tiBw	%t]qFnrFngv+ngv+ngv+ngv+ngѕ)vV:
": 0x°	&0H#00 tiBw	M]w:/%08Oe4qh<ѬyY`4qh<ѬǹѬǹѬy6Yd4qh<ѬyY|Ff=NK{|i"/qn<_=NR=[#'Iy:䙐gAy6	y乐Ayy!E!/yvW]=nסJF˒*F˒s3ey5eɹѲ伆Ѳ伖Ѳ伎ѲhYr^hYrnc,93Z70Z72Z71Z73Z0Z2Z1Zdb^:tyI&C'׻;JN21w:|ڮn]P+AUHPAqEPAABPAO6a.;!֎}u,u輇Ѹ켗Ѹ켏Ѹh\vg4.;eAFFq qq0qq(qqyѸ|Ѹ|Ѹ|Ѹ|WΧy<«We3zUv>˫WeszUv2]Fn	*&(VB	$(>*#(&!'ɑ?yq' |
i#@>:w:%v:_fuh|Ѿ}uF^7{o1:fuh|Ѿ}}F^{1:?fu~hѾ}sF^/{\:trIJC'׻d6^:txIfv޷
wTOP:AETLP.ATIN!?O!?/!o!8Svbc68a68e68c68g68`68d68b68f68a68e6IU&f6IuM*lRq`6sM*&w.IŝlRqb6M*&7׻d^:tzM&C7׻d^:t]o]00A0Փ<-r	j%(J	#(2j"(R (	&0Tr/wC]vסc0[UCaVUpf٪lUudG1[Uݣ1VU٪lUuc3[UVUf٪lUuOb'3[USRflUu;lUuVU7w׻d]:tywMC7w׻d]:ty]îC`0F"`I `	J'h	%P*	J$8" jJ!
'Su`.`ס{:a=ٰlXs
k
fÚٰlXsf60nfÚ{.a=ٰlXsW1
knaͽٰ^lXs/f60̆5lXs/e61G1G302a},aM]n3zסu&zסLw]n2ݭwtwڮo]0'G0`SD00A0NP7AKP+AUHPAqEPAABPAre:toڭv&uwxݤu;nRwMI^7&uwxݤu;nRw"ME;4uwi/_ÿHSw"ME;4uY̶uzfۺ{m}6mm20d^:t){MC7׻d^:t){Mv>wLK0*CLH0lLE0<LB0TOP:AETLP.ATIP"A}TFPAMTCP
AE$}p7u辔ټᾌټᾜټᾂټᾒټᾊټlp_lpoa6oa6oe6oc6o2737ۘ



M

-

m



]
f{'y}7yýټlpa6o~MfC7ֻdZ:tkMfC7NuvuO093L0-sI0!xF0HC0	3@P=AuMP1AJP%#={!>}!4P|`:t:tl~!9[hl~1Ü-4ݏst?B$gMS-4Ostl~Y8[hl~EptB2gM+-4ݯrtB:gM-4ortB6gM;-4rtB>gM7a׻d]:tvMfC7a׻dJfv~`:[
' `x	&``i	F%`H		#`0F"`I `	J'ې@AJ	#(2j"gX~5cwzlסuFZo9ilFZ9illWFZ8ilOFZ8il_FZHSēco6ľ+JfG(هoV{{zf%|ax"F>Nzܲc̍27>]%nowƧYD9jHn|:}N\p5$7t
W|[h)qoϲ矡w/y
H3{/\:ǡOtQޣqw.9qM޳Fl2ӹsSz*GF39iΒ%?g#^[===tdޞm\zK.X7{7'_׿-XDk}'ϫBЯԯԯ`ԯԯӯ=ӯҮOzYyNPK&vFPKnLargonaut/Contexts.class{oGgvsg81ux:\BLX&D1X8Cm9̦nKUj~~I7knua$X5:T{dJ6@e"&:ɀr74mufu(q
Ĝ?א0|vly/WZjު24:v5ġź`HmRUsYfMBInuWVn9MfI=_h-խ38die/Cͧv6lgpI6Vc6HxZ~vť`һ1YX35[Uf]{mGYo*q5-еZ-Gos?lw թ{nfAcyVSIQhJ."X~4"Qiމߛ>װPR0!Ծ9R6·_c/Pq3ٞaUb{ZH{<bWxNqEGOyG
bx~|w¸@V.8qߓ2;!Ol,=2R8gP'FOFݪ0-9^_ԫ-==7V%-+Prje99j9WtJ%}XқJMmܿ}h;v-uaaw`.L^տQ?>R?&LSuxZe’jܢi~ljhPKZ
?PKnL argonaut/CursorOpSetRights.classW[S^[l˖&GǐbOdCɑm"-'ГLydsNtzfzyigotI4ߺn__6"-wTEjd\QKG˲-j]WgCYl@hV
ҁD7mLey@.hemHZ,0SMKJ&O&<_*;Gnh4襫'3$#9{?CV6%}f{j柀)ŲWiO3,rz{hc6AKuRB1úIͶ0lee3T%*"Mn2tYǏiynxC?)1f?ydxv"ya%$:3vV	cPV,DLM&,Go8e)螈;a#_lytKzHe-P]94l͈=iNmYvt,${/`^(䄀`zKUMtaWҞy;J, [UN	?McASґIC6hFK351xppr/=Х #I)
U97B:H|S	_(@WXR:ʸ֩R^50cBt-U@DgЧ/pb=;ՆI/섗rIA
^v#h\Ґ!=LiмLzL]VCҵ̉.VRJQ>YjK	+'H3;޼V:	Dd
qydEM)#	t|z)GOCS-zR6	5f7I8 3
WRsDaM`@韔&%MEFis|jbZŵ5;zd0\|\`,̕u8X[Eg$e*ԹrpQRe7e
OaK?-o=^kW(_;sVYYO9Xglks(A_yX~5j}E[YUt(5XFӴ8Zq
VB#h[߂-4
C*jc#luhz]=oţy6[gu1:wVG1}
l>bk؀9دcp'
3OL!F?"HC?B]]◗'S#QV
%bF]ň$FedQFePKK	CPKnLargonaut/Cursor$.classmRN@=Jo\6jBB[*HQ'ݾ.; ą":{8bc#BQkJ0P:pGeNhdk	;0=T[N(`C3	q~^+cϱ,#RP
QS-pYaHgb򰂖ZQA:,:KdAB>N9dv&'QᙤPK5,-PKnLargonaut/JNull.classZ|[U?%i5mkGtM_kX1H菵e6Kڦͯ%CAQPPQPPPA'hTTEQEQEQPPw^ڮ>$}~s{z{pJHXJ%l 
fsƠnlpQ"eB
J64 ѧ}O6B\V5wHn"5OVWe+:hύZ+݂i7I@q>a~Y[eď#jwZF\.5,\=?VїoU._Uȫ.)*m(1*k(e՗d/T:7lt[l~Wt91*<08}&	ݾl]%<ܒk9|CMuoq5գEC[.$2|UszJlO(cy5RrZka'UmTɗ\WNs"D=`F*<[_Vk=:aw|)uՍeQy>#PϺ$gel
,k<)mOwNZ/M>pHno]i^E"ҽkF$TF6׭LvWip/)˕KCM}°MGa[di^S4:
x֐BLwZauxs/gFRf#2@~juz!@z<\i""`rOHAށG{~ryp!d37oIaC"\4߆Hfe7m[ѥp$Z`#Wx7R‰_xRUp5WXwҢNp
\K5>E*u,B]=HU<]y=@{6ԍpE*nCX2ۧT߷1gT#Sf,+6=LWVپX/2ӗj<@8xR4y"v
nj~o'4E51eOd	|Hyi$L`7g>J7%UQ`'w
Ex>[K,=hPnN*}Ly3;
8G1!ʔcMQ/'Y/'Xf:v7y
_,)JdBgضkda,{-E(cc%)Z3ּLүWq+&Hz*2FV
3\$UxBtdo ra)p
&̎fC_eϺLRBò*kK7Db#Y4&o*BϷWxn9FjMF՚#I~
FϮr|&2^d!<ɯtYܙNi:crcNpg1X1*ē]iLm2SwNfI\˛Ux&c%3dū T!9غkU)7b(@p)iTuUl		d-+`=G|6Tdcfp[kj@
Y6Sh֤5ZtvjhOS>|`wץT'u3R&q>F2]uPUkF]όt13ҁ%HH 6#IZ	T2PR"LY*.I9
3|wFTws·HDGh=3"7	U,p/0r6"B0lnBfaՈtN0nT"RE]tIJOו&]*xF__uf0wzOI%7I7RI7-IR?Pn5|Zf]a8nSeX4|Y
s5cn{zK}p?m#Z'}S%=`v~7c-=xS=<I?0jR==
I?27#HM%=aFTJzҌ#><-_]h5lDs&?ϛdnC&M|7#/t?z^Uxxo.l$K[[ӡu$8S%ϳl( 9ӥ?ku
Ye2")4jeYĉ||eгu*~bY@hPKʵi$PKnLargonaut/JNumber.classWyS?Wҵ1KL̾ݬqɶ-LA:?Ntf[t_#YlI[X;w{$߿INZ4#Kk]-:,5{VHg*+$׎δٲǺj2a"MgKܲ2oV\Oi`0w
/%W$F*I3TJ
eUFzПJVde*$3sm@a˕iZ;$E	uƭxyrlz-.rjX.y=;7
P'rZ`LVfC$֟:h~hr#2+_kbB]$jB^Dj6N1\cڿ#S?kg|S(uv^4׏f)]5 x%fҼirJvv&FHMrmPZ.YYXĆ^Z[!U'j$fd4G\ʲY
"=+"Z3T$A}m742[#s
Cgͤ2й]am>h۲5
ޗw@]5USgڶu]ZIY2U5GVʓ)Q̧Yl!]7L҂:!~d`]qE,2&jqĞ,]~
=18,"X+%#,+[x|5=HzsdEp@7`˞U,-BtxB׮2#0O{(fV$=UwǶQGxQ7r([:-%h؁2eH"r8P7coT/q|?=xdۏ0	&tޛH,EJy57KסC+HݝTUpT asŊh	Mp˘3bf?qt]Cbzeqd[t笘9_Aӿ=<ӏ;[wscr~GOP<(gl	>cq.س%/>'S	qي_"ZN$-$Bh*K많ʵ.#_lq).ZҰ}ɵ;}`}`PKnePKnL!argonaut/DecodeJson$$anon$3.classY{GM8n܋me'v5q@Ҳ&]ZM[hr(

GZ'Ж}Ǜ]YҎVO7;y#sfء}F[t{0>hs'72-3:;>26V°E2CA~]Π[wH3Rblpzcq@Un^vNoei9Y+P.U͗g89c^}A:?*̠(BU=e@jC󼶗asjV=N1V(ǍQ(ZbY"35kSRT
PpChE2p]QtD$*b\Xsa\2z&"x)Rܞ>Ϊ9eM*bht W`BW|]5{F2`x%/U3k5v{0Tzx*Fq
gG92uiyU4jj,Q{4*a?}CĦziX9ZRS%ewɕ .(dSTY4})~j6ZO^U1Y㫹~s~c=FerF\ǹe:w4<77q߼:Ty*`[AHR1,3GIw\1۸/O0tBX!uDS4g(]3.|PfJowYnUlC/_UQUvSb
9z
Шiޘ@Hq&V<#D팼T
rsT(
J5ASp=9_LVhsUtg.eh*gh
9W\?@:N⻴GȪ6Csxj'D2uM;d1$(g@L8\\3`c\uPI7ROBe'w4
!HTN9DTp[kHwptJ*AbJ,j!,p[C.i^Gutqh	Ra5Mgy.Ŋ3<'edh\;:D&["Qi
Nޢjʷ(ު
i_dUpn_ƛ06xz!=n䴵&}ʯTl3NMQ'(KtnmÝB nm.0e;-졭
M.~ޠ7tB۱!}$ޖ_ŧ	?VR@<//gF	XH?{+#$p:R蟅;2=qлfC]zX@C@*@"zJBIG`\ž.a+iH*k$LS.bĎ7z4^%ϱ8裔,2߆GkZh'ZͫiNsv܀[u;Swpc >l2c+mǂzP	maIACh[@J@,>MMmߝ?O#Ռ%H8:Q?YT801%xO~]({''p0PMCTE5X(ÿ8PKsصbPKnLargonaut/JsonIdentity.classWkSHM2F`68@HdcylV͇?jkd1AxZ}Ϲӷ	!Y;Ԫڅ^jԪ#j'/ ٥탖>ժ~h]휗p@[!کdp>׏OqazӺ4*Uͼ8?d
YC˒ߜ~?]̜[-,eU	p=3wJX9:衚. tTX)]* )FYx*(a4cSKΫ/:'O(oMUjr`M@w8(c>&s'Ə(n3Ve.$+,Da(﮾x_
ţ,tOdʓHR}C5İ27^1<_
o˚M/W'$|Ø$9d3tjl#ES\DR}5S-@:AM͘׻(js–T`;gV_v:2qoH`H`^OߏdPOt#~G&
'U]
^+‹lvu`&TN~b3WeYU6aDWE&
	AQE9:H=XܩFr!i?h&(L@Ϣè{˘0k䇗p`)S闹ڨ_#\
vS$M* y_ta9rg
+Ձ
#jp#>մ)]XI˙s.W;جWÐxЅny&*RbC?6	k#@F,AAϫ(%(ewQ >`槌H2lAi@sW(0cjX)"_-<=>=
,>
}Gʋ$0d+q,;T@ &_MN\vkj絳6d(y}y
	to@/I7D"AIB@:jDry+?zaԪ@]uq?3"'.x[魰[J"QH2I5
T]8;[!n}Dz0n0VFU$	2d'7	oAxJYYQidjݒ[tK0HINt{"6>LhN$Q) \B6o+6ZV bk
LR3667y^cb0qPsT	mnvn)ϬQ5̹8;"Y&Q
KؤtNLbJ5Ԫn=ε3џm!@߶Us|ֵsͳS]pAXD
#

۲~Vdrfd,	|i-}%eGu
C}
o\`8w\VkfkFz(UkW._|~y58|D4蚵XKs>fwJ^)55RTvy jB͍x'b)>.p&`^1SQ.kC>*X,Tu?L}BE*l8=e|ITkisEo3)n|w_v[s#wSyLY͖suK"¹A#e8R\"MYXfb;1C2'],3DƔ]r)ʬ
3]eY>Z_
LMlbein+rZPc;u
qh.O;Ws(/Xǭ6M%	bWƹ-'Ogeyk{(j>9@[Kw4ΰy9H\+{Y0N3sMin7eoM^3=be[n$}B4y䅎cop'fھiÓxuֆB\$#G_+SDsY_"pl|{Wiw.t%LbVզ~zOyMt7=9Zk{
Gsq<<-`2s.U=r,74=r&yl̓z63FT<FÄ.Ė{
cD59tp]6JQU*&y)+;g3&2OZk
6p›n0G^UKo	=ȪG77ja
_eYf+=(}Ճ2*1$UФk,cՄTT),&=@tNV98QkˌXg!	)<82-&l?4*eCe
i}ptJyejV	p-#fy_-	+X}9$p	W,HC$duY16F;Pz]PҚggE+ӡ_%]p3rIڪϥJcm~֗}iYkYU)z֬R\Hk0W+rQ:2ZRIQEMΩoJ(UM_a`1&AëL(w3x[TDl%~ۖ8n$[ѶąoĹVFb+7m#Qh%%nt@0t[NA#qۖxqH̶?v@ǭ\[yQ#xіxqHZk̆~65fMc6xQ+vWq|h`=ԏ~*WYO\zKһހ~~%PKU?PKnLargonaut/CursorOpSetLefts.classW[S^[,˖q5&$D$>6'11‘mal	r71?yH;m奝{O%\b.99̠u_
w
\-\7BzW3ˊVv3ɒRV4@WX-/d7$TUvJJ-ojQzU"
Fl	HФ[ T 8]q鶛q8G$_?ZImZĮ 0由~8!LҴ[zCBJ_>K'.Av@<8$KWM^#k]E#?:W,cOVEA	^k
7k"
6cWv	csBan_OxIJU6tz9Fˮ}nѴk/9aS2Ji+jL]FeXqg謼%+ufϋcW&B>lڶ̣G1+3a5
gWL5j5sFV0w`a5m8lWcW/S{ZG̪\UM+K7jbS͕;_ݳeC-M1:9AwNnp.j^SMޥFXUk*$M
HJ+)mGǪ="֍
s=| g@C	W:qt`5ΖAÑ|>4H?qoAAGE iP47&(o&#V7Ʊvk%ޔgб38R8r?#'MA"?ss(~Q46"sD`1&t	l߷ s~>ʦq^WO0y?@tڟH~{o:\sATt_$E\8a0
M"XB.p\WKS$?:F*sLA-T?cqf/[]|3b~˜ˈym6-v7(wz4#b1e'^(ou?۞# Aڣݳ3b8ַLCmؙe4aӘ0~fjYѪ4KFa]5cU՚ 
1WKllcu`V<*Pnp-^vq>ѫb`O^&wrqo``4 1mݢȇnݪ	lhFbھn=Bmy_9 9bsLc0q6{{5gJ;!\(.r8Z|
A\%$^onh(}FXv;jT&N5yui/P(f00uӪfZQӼc.s/%+g"_j#=GW+w(;QJ^RKljb*8,@Q{Xq}PkV;u>"ԘgXa8lP`	N*
2w}z0* D#qQ}#X*w}@A0CfѓXWPC>
h
dL^WJ
nhN]Moݨz:<N.^YOE	]mssMiBO,sg8!x5h*:D8&U$LrIn2]Lt$R^AoPiԈKU;UZP^TSe;]{EΥ#@:g]Eh\䢫'E0-!" |z?KsBHJH"KGp.c~D>䛎	S-w$@o &1 GkgtEbX=m|g۸Hr|1>~Ltl	b,㓁`Ecg;+2~`7cPK~-~PKnL$argonaut/CursorOpDeleteGoRight.classWVǟb@H],֕@HD1H$	]'E^^Bu-]I|?Ϗ{䯿	Q멊82RMYKTUޕ`Z|#K\\K]b,}i )FR}DlN^Rt'lc~u"#M#`.Ɔ#Jsl#
S!z|޽<
Ş2JzPBq,Nb0ʜN8AS!I0Fr\_!eigj1S\4>>8H9~4r1w	̘_EkEny_=Lm̋TB ]t]6A皍{_n!/{^I5,UOZ|5z˻!zVyGۼ(f{ʒ*1<?pOzw#1t7#v-yҤD@ϏCᠨ#CT=Si/2;|@{wֈP;&+=Dcg[VҞw>1!p?|/00q+Q*%zBHGbz×O4鲄`FS_F͐4P5Q:kjDYURLj@]ANLZK|o7]VSA115ީpH_~BZ:"־LvEa
4KCg!i)Vզ,-iT5S{hi;h,<̧!I:rDt(jdCXص߰2nTLe>b٪۴e[M"ᭆXhIƕE>
dU:ҺREᣑbD勾$(jfm.S
%&_hbun"m
n%M H&&lfHq@`ҞShwtmrSpD@Ҕ_ehg}{-٤>֌>K}ѱz5ϝ8/uѐAؑ^<֭Zꑱ	N[b8<ⶻ6k׍ET}
G~4/[#1k΋SFeMs1H
jMV4!oXϏğ?_XO~E^!8Mpi
ȑaxo.vü'DIo@^w[F͡(qݮUMPKJHwPKnL$argonaut/CursorOpDeleteRights$.classT]OG=lo\ &
mm$iaJ‡#Yrj}`FF	"kGD_;;w=sΙ;_/jɐGTu-6V[wf2`r* 0.t<k{K}̐,w49	`@fJ]B᥀ҖV~"^{d1ĐmÐw8+o~UAt"HV>|}hhOvg\Tæ#][QT
q}fpaҺQRQ}QZ]ٌmdpZb0'GdqcA錇	|H^Bq-]rwCmAjJ-SWEmE3K>fs9<<~{ qsVQdmHb3XfDx[2R
·;Zӫ!+Q
$CFHSti?!K÷4F˜!qàKѤ$G!ezCi3`#+tΕ&DQъa}sj?L<8ŧ_H	|3y9t0L&!{<`bsViKq!~1ffi|я.2nYosJ+ߔ.1TZ)fߡ|HbfN"3I[k"l?2*fPKA~3DPKnLargonaut/CursorOpRight$.classT[OA.P+jHEP4e^1h|G#Rypso̙Wa
Pà%hŒ'6R38[5qé?Ћ驚a+]SAAG6Ykj!knD._Y[qQXR7>42$Tm1d-lmQ:-m+[]]5Eå?+e.PUd[vMl*W)06A+wCd[CNU^e_j,pi3FIp*,.y\V&9`I?jbJ˻&= 5TeEQ@RӅ:(E+eQ
`5^܋XMj˺V0tEKz["c6IHe)8HL|/
\e=P+/"ާB5e}|C̒
Z8!ΒxM>](Q$Cx0Ati?r!M/4YiOb;Ⱦ3](؀4x_[b11.`N[K{c7X8I+:Dؚ/|1	g?|꧙,UIg%Gy~f~яՕn̑5I]dik{ac$Ø٫؟bߍs/9pש65hnc?673(d:1oxLILCs34cQPK}v4PKnL#argonaut/GeneratedDecodeJsons.class[[[~}hl9h4
$ݜA4@`bF1@f:3b?z}5@zźK5FUF?5ֺ}
[?zLsFwF[]n{Q$Ff%eUdiVj	G4Hժ`,T.HnQ1#Fw]S8{_!Mr)d=M9	S۸ѺgϿUbSpfǐ%+^U*29#'efѿZ͐!W_)*YFJLi*}qPdmaWU-43f#T\\i;Oe.ILL?icت|.l{egǧԦFVrk_v60@[LE8
فfҨh5Xlpm"Ͳ
bγpzZu$4G[
"OImsWKe6QT.r:Qe[rԑr[
ni7Fl8;o.ʠJNfUFTS<̃g-JI1xiꙝ+hl**}˻bDk*?]ߝ3+5?'Xެ,m:YpCș	O OB`?z)Cq$e$czژWp=fcR=64izbE{Ho`=܀꽻~hIv*ȇI^Tb\c8FUJ|NՂ@qJ?ӇLO:w7JldTހb|`II)jERgN.O;ez%KW0^ϿC59
Ua-2e[Hi2Nn	\,gTV
RQsq]^"ی{ame9oTX,C-).-Y<נ㣍PF
$xӪFffU*kNUdlxH,]Vb~BX[cj2Tptdbf/M^
냜lx_O4YE6?>ĊxM5HJrdza)k3</.0?/	Ȋ쳎uJ-ŨI
E)\dY!sz^QQkqKGNign]j:4Mrpch =1P	퟿EdE^o&`@r.,1y7e4'Z1x/ӄG*hܤbxh$_f%A6*[ܖ_
(_2C-VeAY8gӲ>ިyoZx(^?KgO-Z`+<SG	"M6ÅēzaYQga]Ȯrˬc/:CLQygUK- GdB~VR'm]f !aE
)x]0h?Tx*ҧ }@PϠ5(FVH8.V8F8@	^0)IhSŭ#QN9)<XqƹGUY-DbN^ڬ+۴=#M+U`{ꂦ2G((N-#;mof[N-{W3&/$-/8ۄ$_!Q5^!lH&-ʊU$}U+e6?&4?gB(!.ğuʹHͪ/0&I/Z`ocVA˪=
k.+46	5MS@)1Y̜/m-@?߱~>ՆzvՀXFֳ;߿x/@L+Bj9&f
L<VjƩo?
O*s_Wo,Ŏl\#U#	d}\i-lz}ynsX3vP}@;XFl{1qnIpW	Ւ pH>i>^-,rhFF[kh~:Mnι`F'Fݻ$ܭֵ:b}Οi#WYsV\i=w&?m{62֗C/[τR!olAC;5~_[[sFP.CYPhzP	Pʚ6
p(_Z8BӪy)-_nLMtM>LՖN7ɷx]1u@$&&KbH/rnۙ<0( Q^`J[@3PgajU(q)0Kx:j0@q:A]
3i3[d:1IJ @FǐbW:0$_!@C/iWԼ$AcCKD{BBd6'>3
y,&CYD.HYX`ZG1b,>e|1X,k")li|+^tk'mX왗ܟXlVaO34զ!f =3;D.k8=3ʠО2 =O~ *;_Lbӳ?	g`z63Lf0=y0ky.:`˫fmc7tDCQy`@z_{X@uL
飽ҽ7PXGΐ6~eSf
y(7E,`p}=t#mkh&hJu
-?tm;ޟe?,?/"Jx^E(-MŐW2wa2HAU˰hdI!˸d볛^VՎ1#-b4դƈ?lөk&eTO2)3:~TkyvoگM$
-cvhZ YJݶ"(U6BpD|r(cC_(W$_Hj}"ZRf8/ XxINjE]+/afC,8'-=:8'[_xGX"
3Ё/v;
|jTi	̠K8Lm핱K8M,)f6QYM[5Y-qPO:$`R-B
H/gbyP`f߃x4
ϲ)&5I "WP}Lt(Ld7<^lHQ}Pi"7TC
2,	DdmX8<~_P}͏/dC#/ Qq(_j6C^!/&$^P8
#,P`	/ѸfXx8]Ps=BȰHCP%#b`eB@,a-,10`F "ȰhA&A0GQIOM)dKz<\DV"<e✡n;,E7={^fzσ=VK;͵`!eRhX2Ag8tܔ53r	l/#yeY5
22bײjQuf⃿Ù°9f4
^8Gg|Id+“0˲ .NZkA)yrQ"I?p2duQn:*|Uf>.n+33an
f>Tw3/g>j{}0i0K'2`ЎU3^jn|k^CJ#d!o1"
D[E!)64*jҰL›S,+z7C	#x$

'fQJcBɈW;0#2L$bP7JaX5TFuWݎƲdaܡf;Ժ1vho;IX;x6 %LwZq#2剜v3	{Ԯcʇ⤋f&X8ןC=@JʟؓCYcZEݯ$د"mWv{%RΚ*+RN
MA#nik]GCsOv×~[,S;}xp=v;"Nϓ1>㟘4M=y3 8&}郱 ^OO[%9MH*zf-c1Xf(NC
c"W߳75\8˽w_}+ErE=:A22Zbql~ݢ}@
;~^D[gv?ODv;ƞ(ʁ#j<\v-A>6YQ&2cg>3Xa셢8te9nlŞOsͯgVVs<[[bYobwSHtIΪ*e`]4P'ʹ`(ܷ񿲾!튀횢|zXmekrO]YEዠ*dCτ/9V*eޚ8fr'3v[?A?
ꇎ%V?t!1A?<s!0X[܃kT\@#X&<=i!){0R۩$RB;d1/[,,h_f0ja|rm@s*&袟Ih5lnա!ZMe)77P;iX[L#("۳8[<>%𷖀q|e@T[ӱ;c'wN.gUNj|
S^K;L#"ޫz>Mmk(`P'ׇqV|֥UzA<:H嫢?`w5n^+cx䝰n8ZwCy;鼻|t^2mx:x:6HIv)؍:t:tBw:F;Ꝏ_P	8TUolw{Z!/{-`i6Q~ۻWTg1&j~o]Q^
	<B#_oi]Eb7\n孀:^Yvvmcy餚35>/~.5|IF!stȟz?݈-@8؁jЁ>vЁy~@/cf[2c:^}Au#t%!nTE >K!YaNrr@ҕ_ζG '
v4!^[B^ׇ-
<~?z6u_Ԋ$Ѿ"e`6{5҇o28r=_@v|);z&@
`FX):(j,zm+V2w'Dn|iP!`j:~	#:~#SKu3]:&asc
F0uK3K3
<72vsX~=$I[y]c{,N&]-,% ݊Ms'c$|E3Xҧ
Rr#X
Q)1D{?lt3,kv2
F${?K7,,8`ao
ÇL\Hfd&nVؗ.Bw߿Ikh@ FP{จ8`
 cǞq}CY@ձ]8.Pu/d
Y;3^3uf~t:3?@,?BZqvI3dPuOp>仒W;\(hMQQhgL)L4s87Ŕԏ/IQw:]B_Z!w?.Rt$b=a$1z@$[TL,&JIj :.6b\~}_صz@*(^@&a
/dINj	8¤žDp_`.uSî :F){K	gĥw9t3y$t3SAŋ_0v	Tt Et#\D[l.\HGl%Rp#%~\~*R8vp\X)VjF\p}5,[!8l/ ,wGB]M<^=d0^5>Qc̡L(*$]Cn\..|%aq|;Q HEh|ÎCOiq򭣎CGPǡPǡPQǡSP/Qǡ5q8q	uu긆:u|:u|:uϵ"^z/bVNײ2+^WX8:<˅սǰ&LQxhyV*ᛂjݼ//ooV7³g~ß5;ϧGfxTz&>CӔuǫ/y2x"jw:{K8-v~^d~֚ު
A1rRVIf?$h$?<ijaٯOt~=4B?Iq$M''i:>Cǟ A~?Ա1[tl!~&0/%ZTajP{_xJ_ o&YK8+_Pr/?k煔{HfS73!/×_""DmjSEN> TG]a,zqMy>w((0>M.\0Bz`wxR!Y}OO߻/~dJEZvD[bD8zV~G lD}
By޸T;߭&~Kҩߒ-(1z˲ћ_؏zPt@j@q t\Feį)M0_Sܑ~MHFb5;Y?j;gbPΦDk8bD
*!{~Y}"L)T[rd*VG
tP<ǘd?Ƞbd&D48mds5p֘+L%Gfx`WWܠ(F"Y]~1@S%Xagaω\FbtLPATO2F@&(n.7I埂
7_ .KQԒ`j40(bT1(%JA?IM=ZzmZАXU*bx$f%d\"oSsϺyPAvD֝QUo{YU M'J+xaBzqm*$U<GIaMe:ߣuT>2kFTly;p!!GI${vhtpf8F VY);⺸c/qF^2q́Vlg
ܟ0jeϭ1qzkvx>	&ADz˫AS"Of%|Ɉ{:&s^MGl}^%	*jeIx+Q<R3{Ϗ
K=q.[r䊋#e0>-~ܢ
2x_ 9k#dY	Fh/H
T&*Ņm3Ϡn1LCrKFK'+Trj+
	7#5;VS"yVQdJE1 qKVBC俓Pm+G;0 B'/&Cٻb6Bg&Wޜu5*WtG	Ix:Gń\lIO7kfW~`4=1+9xc"UV'xG-k[h/t.v>l1CuuYd<ڊ[ wX2VHg<%zG1BʾVMqy]i(LD>oJ-Ks*-)pf,@!5*U2B=2w2FFH_	HŒ"ZY
`]x9aҴ`#eVHǴ/ݠŢlyLn=z_<ɱ'KlP?>nB6Gbm9'(Ǩ TL7 	߼`<,szz?C_'Þ9[YLԐ#szװ\	Cz={hlЃV봘w[K=
;,?nA~9:a{YSXS=Rq1
H1V.ƀPac>=Y+!L$>+ʁw=s'GsNs=}O;p8tIS /]j)Vț|wKAXW~cDISb
s#;>>>$e*a-t˂@A0 h!JYd+E&:	S<
W3C2s+tr=[1 ]{>A	am$br1y--яs|ߙU*3;Q__b'ܘu+ɅyC~HL:q-cO8>Jgc&+6Lx5јWEW'nQ2rT_=WҚA7r]5&SWB8<%nX>Wt\9n{AG>0K#Rmb}䀫Bv<RΊsCvKRA!C<#"d#\߰y[scY*Gr|_D.9?#Rp$tGeHdV6]aEqcd<;KY&faS6&r‘]UGh_j~M>/m
Unskw}d wsçΗ6'.(O|zHF4jpJM1[v<`](ӎrpї"b=ϥJG?J#ĆHguOy,}
tprJr,UbiPL;O/{T=t"iFQel*6Q~/
dwY1DåYB_0ѵwR
᱂z󜂜xkrCTr;H8ޠD!B tE5HX's8 +`%Fź*
yt	-kdp`
N&rsr#O0P.r~<ޯJLݯ*/a> Qh8mp!d8bBv1ߊ|]Lqfgr oƎ_v>rG_DwJ,ϩwMJh$m8VK,c+ht*tKb@жYֻXJ%e
ʡWM/|y,%8<VJp/q^.v{oz+Dm{7F(
R6{<η9xpמx ]5Lߚ?3h8\[k~O3L[ba.{&ޑ/E&p\&]5qPh|`#2^;蜎:1Jtv`v$_+ћR6^_"z@;C;9vRvr%]jVMeG\zvTJa^GD(=xz9Bs);G9b,aȀ^:UljCKh:ٯs/>_~ျ*%пȥi	m9J|=Ykhuvzr-.>#w3Mû^rsȵ;>~>9Χ9+ox<5~Oj۽W.CPue!^NtUQ遗d3-l̜KJt G+P͍VZP\ë~ժ樕;|-EQek4>P.Kӕq5_os.c"kH9"	6c0aFoW"?Z	4_M\0ڗ$`
C>`:0?˼5'I!Z9qc{6,6w	R-|qلk.E2X]?@ݓ
7bnЇ/Q_͌ٿÚif
"d™&)9jX4s0	f?@c2MG4)?'zkg:`e7=|"[\Ѕ8PW/e^6kh׶~5ݾ:*F/#\FQ~ESZ|ָS?[Nz܍:6c;oNg	E^K>xܸ;*ћƺyz5MTW[u0ߞJ۸E	q2
"{pGJ^,;Q/R2![	`9rىàFyksLJGr]P_GOp79>("
/›@.4f'7#f+v7jk͸\mGUs5*]S&r#lZCPOd~sUonj9jGزGs>/rh:<#GsXze:˛^|suX	o90ҋ|	rK{X.c%!8~l'(p{9b7gV~IQz[ק9ẃyr\'~7bAkA؞xJ4q:\ژW5gx<,/=?RZؐ:N/cx=8=m_̈́˜%"{l%#{D1gvwyqXF6/#e5Z)O],TqﶞFQ1Ӌ/*ںŽӼoأpl/1W
qT"vv
,÷EΏ1J{ؕIJcu@
pO,~@5lq,4npݶ-*VY4AQ[\(i^T C\GJv'Yp_,T
t5_Lڜ~^k	倿g40%%4{0v@C2֢{(vkLkLiyPlE`2`$'Q"8}3zt=o'뉚չPL;X]G:[hoK8ۀoXanrvBIt<'3Mx.MxxKDtf}f0eh<4^0-]5?RAbe1nwgH#yw^3T߅B&ӯ>;}#j{5Yj٥=:
/ԦDȿmOz}Q>lGS{hdȱucuX}f";Hd۟%TmaĽ
Gc>w0[s_7eT'"=$37$+h_Q˘?}XhQJ0b{F19 y#FG	'}}o!dƛyv>E7uή:t?'$V&̓jx3~7;]d=Ks"6B/ x8ko1o|W$#&O\ӏ-j }d`iqޏG&qmKȏ%~(3ǜf藷imKMuv~qfi׭i{wwúŅ'S}q/wGB(r>YI~7b;~&Suvi1,fBr%ʧ/%Qck?Tx~qk{!Z\PѾS%Ӻ%ҕ%zYhCŭ|R%8ZZx1;JFp-|%<$<]=]RE1:%
H^1{wB@>JSg2\?7P{7/ػVdxgxJtWPmz;/խjjJXWd@7\Z5C۸8}UZu^Eq^[+cv:z8Ү7s,Ӯ}vSW:LuNd/\ؾqeu]WWپz޻cŧ>bYw^7nZ[,J
_wYZU?kZ^xNe"<|g
ioYm+Y2mEQی-͋LreIQ(UL+YWom9>\ZҶgz?49:}ή^S>ZWj3lg\
9V]yJE3)45PVAsH_T='|+tKvYń0U\ ~M]~}%eIeaN2]&z]ahX4oPmV{Q"ZL7L3X}(SVP4=IWrǕJ
VW
utJ\P7iSQ]F7BD.ujfVgRya'T*v춘ա{뛈Jfo3>"ZYFC&-*XTy@NkUג:l5%s+⨗24P&iAw4Nb@.&-sO7OjoJKK]dabN;9]{$fAZaT!\ҞZbM3nkWEsP9<+|xiޓ,ش‡9gƖm8^>Wj-a]o~z;ۊ-k[L^fh!zzy#[iKLљsZW5yN__ꨮSӲ"Ϯo۰k9hkrmm乾ĴD;[Qdkr.UJwNo.*n)]r@ye?gqֶh|^;jK]rA%Q
eE3C90k~ˢXl;Aʏ붮(mƌ]MۺEO+]׾bVz}UU.rTY1owQ~det*_ԟz:NRyiUJR`w$;B2&/Y[Kt_u,{~m
O/?ܷ1,pQ3/;yԘ*āa,h:˃'|%[VW_;#0>iWwu}+BMxP5vD
#ػt!:Vx|)yuVJ0}oiC(C{'|mcB^0<dKMYoNci_k"{+H<]NYʷV7Tdz{|\鎷dhRX<	ٻ(\Qq)S՞!),]}F[tj=~mB$iXrjT939zӽ1TTleӷ*V].w+t
[B]./eGW75(xz_T{75[*ybJ<{qjFF`DR^]Fig^oVIKH<{hjޙn[KE$i1{G1{R|(J?nuxZ@HiPFMJ<ٻ'f}=DMkW-d]b^JCJsi}!N-IBu߰k$Cld[M[']oNW[zk&k[l׮lvݻnoC=:ZM"뙧rk;)77,۷=:\вǻ}#
Ё6gܬTWgY[bmq7̪840i\պQStٍ"s׬8<ضy4G\e̪X0лKLkE;uֺy3G,讫<>jgz8#m**v
or5#C-ك䙍#'[:
VlJMش*fSX>pPq~f#ׯnWԒû\K:,JA&ht#y+9hi`XY)q FMld=9p:J@Ӽo8HץdB2;fTVeV.
Ae
`6R!CF@Niw~l(#e%lܠ>A`@Yp8t&fKFٍ.7
u%u=N*)R5ϯqN;wXjѸFʹ+3i$XYwPsG	?=SI]D׎+#vg%t`DX/pҕΎs+hQ'3ΡQW׵OYQ%}rdٲ֘7TVnk~a%~$@2w9u#+(AGȊ|\nwߩ;&+;#ڰӘW/>VTشedeyh&s&LZoƙZ%
A-*ΉMDwP^uY>z3k[X]o[v{Įײxv=PgzӚ6h+skۻu~zFvK+nYbnelM%uZVbGf3nSOʎ5c+7VwEZVϓ7ҕ0^E]GW4EWvn[Y6hssߡ#hnjEN@Mk9mP_j7FGWnjkln;t_՝SKtG;:Y)kT<y?)ĉ4мh]3\eEs7nس}#LV(CvT*-H@h{soˡfSs{sp1+37ʚi.֍ŦcmcKW[06c7n2-pJcA$:T*jkJ`pwjpDfjƏSn,ŏв[VBV$
646y͊sȥk:kuϋÏd	HPMM_~r`^Qg4adэzkz|"W$GG#`G=*B#1	15(\*I}|]*#?;."8~s7rVe`)zD{A vk}ESXlAM UL=+eRݚJřJe$]AltKYzz1g1,D !;zB9x|VM⫟`TQ+cNC2:7F>paLY	9з4d*`aܪiEcP34#z8%wQw_@?$0
[D"!'&L"Nw*P>M/aoJ_B"zrl%p`Dkoo	6`-'	aY#bXMISy0,u`.ckp4XI6qju`~BϷ'
jPIhc=m\0=`yX~5f<k^
kR0]F4z_39|
Pb?KBl&v~aUʃ)f{dv@Zr	I%+26apO|@8t|:z"\G%ZG,Mbu~IE{"\'/]$5)RJ-}2^.p),Y`~2W58&׃@
GàbI0KB3S0Y gCF}0z0Ⱥ0>;/}0~><,,`dC@.%bO$Ѓ!C!1
WS:0ƀ3
!`ѥDx#y<A]A}'/}0~Cp)BY]Jg8&҃!C!sK0|o4_)$T
?<C8ց!K)1aօ!և_a^
W7:0ǀ	NHv0Dt`R"	LD"z0Dta00DaxN~Fàb1`?tp063 TК)+*~BF@gL?!	fkEZX;ł"DpJBfH	WYX GJI. ^}@, ^}@f3ɯ€ND;B 1)\"_6d`k,ħ`{3laPM~$[X9BBgHY_l'jhAį_6BH_`@V%l2F-PpF r6dokzdq
Duuan~-l_ۊٖ~-2F-4Jh#@6dyk,=Dg$~{oa~ȁ@p<=@$@h$
  A=@2…6(HP> l"ą.=@Sq_1rqa@B8@Ba6$|\8"\HLtT. !}@ؔܫ	_;$\T1r-.$
  a=@2̅$HX69gۄɯrC =@υwJh8@"a$]x@ޠ)ܪHD> lӅۅ_@uN=@ԅKhS}Yf>L=ljIħ3u'рXxHX%T-|&l2u_O/Sb@%<n}l#S'1 _LdL)=@Կ"8@}Yf>L=7gn}Կ-^P(YE5(Hsd".+Lg=5'LS$ͼtґvV̧)|b")n$@)MkLg=SG߂D`TZ&2δXrl6}$ͧ2D20K&֌63Q2c">`>1bc+)7JOLt%7S>״|	Lu5wJDOf~drL;Xg"e?)?3QL~fǭ̇dpΑݦ"a:sFX3
&cj7&e@FN@2ݕA;@[2:d~fLb23$&3Lb23q	2IOBL|b$'!&>	1RP8Q]E79ij^ab#M'^x`Ȕ~$Ÿg7
Mz\U!&v
3SLfb0;)Na&v
3q\s/o| ${6>
hV)
A$e0uW^1A4jvI(hg\hG]Yt
k
1`"L\aE.u&N'S~}G?Qf?W8*Llfx
gppQ{<*M
|]!,X܄E%**EI,Y37R1#>6C0>leO/}zFZG]yٻwEZzu
dZ~fxǻ5EKHT/U	W4hCXhi8,^	BAK={%.EϤۣ,^pSxy=8f}
}ldc#cF>62}ldgu?{W~]ٻw?t1wBz;
;ŢMEIE/4W:
5`~[vz7p^z	Ev!,FGH
lgve6j٨]fve6j\BfJfJf*U{Wqzç
sp,"ZAbN,"d3Hn<S'E3rQ/N6@x AIKhU@\NB,$6X3EL]%f6E(lF`3 Qٌ"fA6	wd*U {WAB]Nq&R>C	%!qߵz	J?/P]O8/_0|ӧwH覸!ƴ")/^Y#h*e
YVvBlbl'f;!6	Nvlf*U0{Wa]ٻ
w?WaT+7x=$^nɴpe`=S0\p8=$Ӌ>u*כ2|y|Y`	0FL,fb6X"l&a3|l)o|l)_md?؏a#{W޸gnCu1S,zĿI#}ʫM[2<I\yEwq=0y
2<0)V .)%4]iRZ0FfuM,cؾp>/cؾp>/lOۓ=9|lOۓ=9|lOۓ珫/Z	aUV9xZD^;Q^ƫCtp@F1E'Ns
i9ɟ-5E˟Mwf?5q?Oi6ۿo}lF`4>?Oc4>?Oc4>?Oc4>?Oc`	1p\`sL,g%M1fNDo.5-X`:i)#TѼEg2tv8Y߱F$tytj>҄C+c48̫g#'&qt$[ekOOr+;{{G[zVnJfS+h-:E(qV&CJj$_4o1ou7*}Vs= pOUskk5KR>hn4 	h^Se54?%ɿœ(3ﱛgckiУ>|y[a>A@tobV]$nZ3	k{Op}a|Ұ
LݟO
vsxRo3TZpF7ӿa̎N5&KcC!a,-?)U&XX!b@T0NU3Vu||) 7~>֕b\
lz5etZv*բyy=쵘)V>j|SҥO$|chD	g57#P+;dk|^Ik}[HOQ+V}|`ӭ!@"Hh&DZ773(JQ
Kn3N	l{m3QIz]VFV!|4nb>9P[	m4?8eZ^N`~86ZE'{ޓi8_K:TrA@f7)WVON!Vd@rw>0H#DpCU౨Ư&4yiH@[rGd~1lu!jl%𜙜0|g_Ih夆îq񚌨5['k[&`3$&>O'2lߘK6?]=9lѷj7	ny:#6ɬwH4L4ox,m|"HhŔ@@uBr6:9trQ#9#Vx5-ne$S0
^Y3"LjZ?Ebijě<+?qKR	m%5-Hn5%Lhfc{/txC*=VI޲(q}7&Lh%_-['%Ӄ4	5XV&k5CO`,Z-5K孼PN-YYa%ΒiAZ|31Hk5![/
₯iD5hE6Rg9<[}2iO`d0̋1J.-@c7n~)!\
.hbo\	:,Z%5i(
uPжWӣE$k TS90/üV@㳌n.K{Rՠ\~م!zP c-'/ݖI/3u
qa$\=\0McjO
r=_*pG+!ߥ}_zXH
*>4A&!<DŖk1z2x:'!%|*w~!p^J-ʳhLYGvrJVЇ#PBZL z(% EPR Mf4i2ɌӴӜ&4!^@M)Y}ĊxӘi!U /bܾ]OD},}$)әk jqyr`	nN$pb}Eʑ4G9W-_#c@'zC	()2*4Wwf8L廄
?lwS%	*)E3y߃4[~Bx;̛ma:>(,JJ&I2Tr 19~m
!?09^?n,1nϘI|jWn!ݿYC
/6>ˍI3_=.
Y	yg&9Nm]P]P邂.((
Q+V7wdZz.H!d4d1uT~EOZd5cXX{[Kct\B֊0&c5"u]WBmx>%bN
d(dXdO~:ZI]=
Уyj}k%j&<8!djdkYh]b]Jx [q銳O^Jc;<<7IΤ`sNݺLץ:n5I֣mޞJXn[ܲhn•a|/͕	tzMJ$e|wff.5hª{1)T{@B}R-&cM4xE֏=Yq:>)PѤ!%7/Zϗz~H>daꓘ_ύy}a뗓ʍ-zVȤ; ݁h}yo`N?^Gg%4`MlOtoO΂,&֯R~f|>S(A>-t"ج?&9+iFk9J@P߆А%@{kױ}RmZu"B+t"D+t"@+d_ʶE'ݶb.jie'Uoֿ7
cU7'rW`E67^ÿ0&5ϊSqoHh؆R065>Vys{`>&6b)߇֡.#aD$|jOMM1Me{Ҏ_KqgJs'<|jOwd&\PPe9esy6F^#m[4kL:jI O|j_O64Lҕs
O\|ər5nی~mKmØ8sxNOq`rDJgOw-âMa72\6J"Yɽp-6LgO7A#m"۱CAo%tmGrMR9bկF*ffs0,CrB}	~@G]^f;H[D.no}JۡoA(e-`>ڬ(}ݗ
}ݗ
}ݗ龬*۳]t{{jB1ٰ8lö#)A_>6
)iVlPԊm(њ֜Hg[Wl;>ƿLB'moIo|T*uUDQ1B11}\'KmoKAڜƸ|:U.u+lo%\	s靀ZO%t݉9T<&`q"]J_v
ta`~;$31NDnWN}Lj
ȜI
ۧ; +D6mdo{	`#7䓽q	~s͸NᆏnEglx
;ǗU>1OKJW{p(pW0MG@"	ۓčn-<0$t;}`Bw ft:E%̭Zu7ǽ=W
^zn8xxdsQ'9)cog֥/ڧ%·yo)$\ Svnm0fv쬒E{0s	fRنMz}EG<]#DŽQCpGU@//&c
+ȐA	`%u
>#&QѪh_i%d_ɾ`53%t}mrqEU!"n	fs*z}[r_	N{@mUEz@;Eϫ$t}Or
7.#8n(S{祵w^oo JΓ;'?\~);Xs}:|dTsl^BDPU;$.{grWP(Y!@ZSsY9n%wj&(*ҢBZT}C|8zFywz@j
WnW}SRR#GGi.Ǥ$}T{W%ds$S-+TLhb-XlQZA;ib-X=`wTj/?N%c+%:ߗr|lsND/%f+S_c("ޙNQa@/X]z)vg}IdJRxbJ?	b0|9kco9٭rGm'*?9YAG$tD7h.]!;yI/,5D"J?%ٿҵ~$Sy'|Nin3gn+q36DPTb>m'S?MB ?L%a7l{D׉%՚?îsNn+4Lz
T>_&U'k'/Ldo<
(=1hw7)_ww!ȅ&G!|y!rmbRg_{|Pa$: ;+L1$Z+_8l481g@9CBw:FA]Ȋ6Ԓת>ar5@#	'8}=(Ї3Kp8<u赴ݧ֡c?t9˱V@'7шsΓЇQ^XmhWtr&[ h0,5GK+985\[ܚI&VWk}jmR~Hqo5=Jk;h{'q5ݴƽָQ5Ձ
zwv8NwIA@5]|lk9\4cc9
Xd7S/;6⨾n])*g[.5WU
g:	 Mugn	}єGm{(m{cv~jCA	}q^
.ƿ^QM	]%o87vt`w
[+tUDf
}v41 ;SG-O=|q4i:M(vc톬M']${'n{R>]U!1!]\
˽UBp\YW~~
K'
7
p#7H^Ǎɝ3T@'x2!ǶS}7|$Q/|8	5z')}nC@&;s;).p8'øq&2@!:nsNdXVATy=mWB8K
2
$IR0Z`*w9>JSX0>
NG:z*aaNVJ)--TZZ~A"-
*8rDOo'_L7>A$)R6ӥB@8%.5_m3e:aD߯Coڟ
I*9/O9LfwL̒0~OBrrJmtncWU'=vE]ucW=U/=vG]:v:~0H9;S;Fd62W_?p@dXɬ@])Mc}~MBv3VQ0vOlRDD"TґHBqB
9csH^ڽҬiX6!(o	=t+YlR8Au*YtGsv	\{F>뜑3|T[dÖ]tWDIZ)9˰j6!>4WBsKC^=l,S8Vu$c-8jy[qbK>6
'.I]*$:;\]{=7NE'Gxg9$
z
_˜3}u|C>s%surPy"'^=Hi6΀3Hz=
!"z~wnJB/J4ή*msD4.u980e0v qK_BЄ#pPsDŽW6G}漒_t^优pk.0KB6	=>.'0wJ$1P;PO"Idz٧DVN$'i{磴h'=EO$w=Dr/=GO$ɇGHZ;i0Б39w:?BiD-|IVz+:opHftN-늝7F| у!-mG8g}.'i	fiڰXL|$9=Go#i·2VCr/IiS)BS|T36Fm ǜG:vo4a6{):M=I:Ƕ=o#i4Ѧĥ]yC'~ 9_Hg>N"?H-BAPt~qb䑿םL^H
B!BHt"qb7}n6w/o8wkV]Tx¡Rk'9+ġUOMݱzZbOG
v-i4kf
'矉{0 Kސ7E\…^	=8Pr_ױHEP	LzVt$WД,.!*N!WD4WD ?ӘX\cF;g$li})|"O)2lSY?ɔS
	}[\ lz"7"vLq*,Q@0#=ݪsbMrݒA8 Ԧ\hFό3CJq>Ӱgpp
-kJ;/A6epFځ# KeDX" l2ip0ia+\}r{Gv;tbHz,@8`hInF,	}O(IÎ;>LfVEqx!vL?f13QBϋ;CCq378YjXG$vՎ ~#OtA:hgNh7C; }3H?rv$dJzQ.vppG20FRFS/TyEqL.}xrO{HX
͐/pPdT,HuOn!DZ\Py		@$7sz2GhMxxDE
pЮq$xu
	qC>TIOPm#eěގAC&!7p1yQeH
AP@#n^vo}}x[
_t$"Gh7톂.fwb$m(Ћ])9>IyQ6/
;+r~	Xi7?pzڐ*,&N|oZxODь)2N{X)H+ED"d->I+	׌/IS)S]{RѦIY? -XD[:oP	|SB?M.)ẙpϴ4>ծO^QH:Ò<悦'\/z:	\|!sOц{C*E)^)P:	#bBB\qr2TA#_$NoJ<1;fi%Kɵ-€AMq#jj+Y%7
Â*VNaP!D7ī•fN{TeDO"y_,aAU9᠞^!_t^
~gР$S:[AVP%WU,
B_GLeu%K;L{
О`z.`w.&]\A+
%w1\/e;\o%Mܠ(U^U"]|&abי
2k~Za62-BI^v󉮈k-؋3m<=f^qէPN;LFCaѢ/@[EFYčvc7j7o}l	uN

ZG8Fÿm'FpÝp!|x9&=518F>0 ߌb\.FKBpupX|TjHaPt'N<p{I~Q>#i6ֆ!#~v
'ߌ\"?N_~c/7D0tWEׅDފJ&7WKϮkRps"!yH4.hň"!7`	yoFWn_\L+~!h⨬>vk\o#jsV[A
SP#Ȣ'AI诮%(2%8s¢<^=!jOHn"K²af48aG0HO\MUa1gDCBa2v;\ v/@X>	AVz^u=\B!eल4~__t8}%yHpMO]&׿qyrFˀR]>EDI,_lS㪔OI/'W5hpu2F/̀K3 w}7|>BA^J=M}VB\Se5hi;љ3v]_%B<phIU=}ABt0AU\d.-T[!;D% l`WO)^J>_>E5ps#4@{X^tHd:㈾QBh(+wD}i(:(^vЫ؅pB&k량5zαjXѰw4
}GjQY;WԾJNh?Mh?OGhAthTшka|@:n{Z
wMQHhrH!ңu׿屸gӣ4RW.8p]vK?NEf׶ḩH݀e
'K-ĞVc(zb	]«9#4+:F`yJj+p_7ᣮ0Fh@,IJ^^J2
}O]%sץ$uᣄ0Fhg,vw}b]pҜ	ޘ§ݘe{QQ#iZiL$a%Չs%:0|Cƃq*=UaѽӽX<.18[Ei@pP_ukDf
dii>@dLy'(՞	L-) FSie!yuۉ"
aEPX	Y>z2uD")dvJ64XA4zTjjw&uk% ,)hq—䔞]*}Y!xAF8VAP4ײ'
 z|2yI4=V6Z~.'9me_t_;n<&/٧9FSJ4qj7nYt_~;a
S# {cxew@t^"{':̝0$N`ՠt>N)<(?输X&'z
I	+]vWꃴ>vWZݯt((pZ
]1כHFYbU^Oɬ_?}Ot:Fc.1tt=)AGLym9S8UFSg$&Kc&(awNC]'<=!4>ƁQ|2uFxA=n8n9v
㈾7ϓ@T$uPGx! zf{_]qCfDH0ݳ4yjGRz?}=DP,,$bPcj}KPS(DVw|ԼH//D7Vaݨ
711bZ5)Ds|Tƃ	S^VEO"FM&%:$ٜBu)*Pڥ"?}FDYKKQ#au[vJ0˳+>
;'<+P.Z
%C&]=[=ۈjUk/wЧ@'e%9BʼS_'T+Pi!ւ&#'*^s<)D`
iï'zO+a/;C9!QPOO%(N8ch)V,iAįA/z:##퇨"-=7zAXs+%3  9/Gr1	I=zG&In5p.G3Ly䄁1tB*oD|2]|O4r¬|Is=I>bC^
j4e22X*Oq,_7xD
bD_?`I@'}qʦ侙K<_"=|8Ws>
59j09۾&BMygk?u[&YEF}KV}KMD}KMX}KMH}KMP}KM@}KƯƧFy[M^>~m5m5[!aQoZ=/03y!nK_tw7@=_HW<&'?Fo]9Ͷs7c緞W{7˟wGEڜ^€g:ࣨf,&!BwQlXK	H`w,g,EzT짂S}3$[ώd7;{'G$Y"wb3Φ!c:!}
ғg{
9u@<ƶW!}۫coC~'v`qX#-0F`ىyM,F`錤VHD+ps'6Pm
x
>N!.R`1Jg$-B\19ˈabc9E#Y׉Ąo+F9Q錤WH+pZFak
0Lɽl`sL'~-fbƃ<)ԷK8##Ea~
_88D')U1Bcg$v-	/@I2öGܡ{YAW2Lc+3z!Jvrs'ζvAM!TRgw{"9dXAW2Mcg3Zɹ3NuRQSN-xx1;1Ơl*Ji2Y9{9&nyvAVzVEKF`N,4 /qi2vm;S_}uGK"Ĭe(l[sR[t4Fٵ,<.dq89^
x!+$KbA{WN64v;EVgU/Iyn? 9O)i_/HqH(ysŸD	QI0(!q$;}AMr?*d
O>6@jKAAV#iHw ;ﴟB)Aƍ	H{wfm$LA
ZE:5·@95`o|l yQXxW*$FSB/";O	4b,Ծ`PgP۷a7l78oplcc9~s[
\7Popb}A}c
.Ko0.VpKFȑ	-#5|2ٓ04ppq/;pedɸ^Zr8?r~LTV&kg5W;ۉݾ"r^zI]
XֿN^#\M.D',9%X⺈glC('B۸ڻB1O;QY#ilԷJ:\

Gjnۺ;H.QW#il7^9\\TaS ;M
	8M\
Ĩ*4q
۸.KgKl?#@($iDz۹ēb!eM@(õk1ب֊M8$+`{WXZ	S3-fhWFi@ 
%D0&;"ޱ_.0_ذ_uňo'P(n
B"wAkN,1\=c	8oAkk;ⓓOEMXAXVBL>vrۉydW{YNc7ݠnݵqԃNuIX=y6{]vbAgx\tOcoޠ7oڟxT@=[R[$gy<.N9 ;<Pi4v8\ .=t+WI0#2Ϻ!5?	[Gn%Di4
:\\/v{$g7AX{OR,4v!EOJeH"y)vwj?erQG7EԧdSKrd8O瀺NE*ht7V u8ɤYLƗ]g"<ԍRCR.BduKg(hQaiqdgڙO;3昮]i/xڹ
RX
¾B\W]Ev)AAZ#Z麜LP7	fRm
BuI[g0hGH \-OelZ](p]纞LewnЂR5(u$^{BVJq #LH}EZE,alяdQ
o%3zs{QtCƎӡ~'ȦծƲ;)"q=焙dwY8O
/c@C׫ׂ2[B}]Hk7ҭR)s
2شx"z_z֒S	;\S̵.T}]G77F8w}trazDN%ZrXG0p'gkCF尌mjq_
t}:#9֒:r@N#TA\<)a"(y`JO
%u䰁~ԗ<$?֧DFrp%[a NGBG80r$I>|,'XNyȡ$сIRq)Ii싚@_mmЄ45i
軑i#IF$MI64m$iڈ'G;2p$Y$PISd/g [io߁hEFC-	ć䰎6Ïr'q0f1@G,?OMb/[Ŵ<@34p^a-9#
#>⃇a9L"4!Z,5_}Q$M;
DǢ6ÑWt$^Iҽ{%IJ$+IWt$^2KrHy/#(mFႁ|dpt&>%u䰁~>xȡƑ$rJa"@b(K",!(禁Fts28plh9\G:zP*BѾa%Pژ=6=Ox-֒:r@?xȡƑ$rJa9\G>1:>7-	0GK>l5lT26>l"|Da&‡M6>l"|Da&‡M6'-	)BGvH!E(зl'%)K]\kMBƭHh1Ma-9#
#>`a9L"䰌Vu9A_	>lI;PeGb?ʕ`߲i\=3M/kNfq)|֒:r@?f>xȡƑ$rJa9\G>`Ö9E)r)|b*B}N@#:u`)e%Fsb9zPpb]x}c>QNMy&-\|2ʈe+|J=t4/k<'f5/edQ˼YVP?]8^e9,;k]ޣ@٭{w=ޕi姫˨Ld?XY@UY}e/bw<9ʞ&*>OuBdb]ds***+Ϙ?O/Vڞg%%Π"y*;MB1->LT	?8߫JbuU49A#QںwIJ)s~F0~qOv3"l2㳲08'wcqƲH0~VaUbN4_Gu6\͠Jf~Q\Ҝ<#D!prDsq#PZ)Cuy&afa%m1brd=[ܐ1 mF/"&taݱ(QSAhw	7MZqtn&ASrԱ|&1$_DK~iBP̙br=Ёg&]5Kƽ-A9! i{rC^UkBb+w%9!)Ci7!J׫krý{?ף@YS(=
4t>8_20WC]5_;+C݇`啂H%KrIse	(Z`h;fJde{rADO	'rX\xNӿV1Z=j\Gk~N.gfCs5u%s|0.cS.b(o>G/B0g>`1q"_u ]A^>A0}(ǧӄY+3}щ17bOv'D`p!LϿ20HkKVaE&#>uB7KEt//!O`>=B>B00d{j"$v:kuHyO,Y4goqSsGݏ=@$g__B~#ĺFPKa"_п.1rTѿ.[,9:{6?	eE[s\ivp{v~ս},@V4j	6|P㜹(z~];LvC0ހ1
|*|`+>b6M*bL0?bR4E0#4QEFI#w1}g+o&;(*y	z(EzpŚDag0
S_ijOā;DS"@,u2}:^@avTKwBr+
gʊ2݆	¼C!ݸU>ZVWtɕ{}$u8[*;b#,)|Sܚk?GO+ƹ6
}63N]5)߳|"am.A)xcS0ʹ( Edݼ_r@1/gTJۑu&cy%Fa9%hSrdQmJ2 8|!ayim]AzǪ|ј$&37C|9_!3Xd^>n,u-_\dS-A2[!8tz	
̨'(P0O8(
ny_Rҍ:0.
&@ozuR&e6v'Fv|¸oQv|DoǓ--9V`!oEʜ[[/ Np
vk9|
u|]8AGFHT?1я;WbW,1>V!8V%eU<1lt?JoT~3}jh%V>@pR9"LQQ|	)ä|+n'\Sc)}3T@1B>FxaB0}ZzE9"S_t eˊrZ!J6<]!o &?i@ʆ(fPP"BJR*:,w7VEO'#8R6ɿN'OL."ſ"3
  dn@ʮGA#Bs}.QDfbmHIDT!{7!8{PzK&Hۺ/˿"1 eo(1+g{bXE
vMpq)dz4r4bI1dBCǐQ1dDCsЧsZ6ȻU:Ÿ1+sOh#^`XW(^*А>eH(UhE9**Xݱ(#V8dmz#*U&cNU(%M>"8wOSoɼ͵IgS|<0=6VTlkOVy/,0=UXY_KʎBvEp^n
X!"#j1k#TlW=^X6{}b?-ER6ϿEL()mأbO")X`l]H%W"80ՅB1'QR(QDӰ\T8K)*\P1B!nEmf[gQRwQqDőDXm7&EXyRO2ORQ1@C„Xe\Xqqhb]0o)rz/wSQA;MG;Ž^;bzaGT/aw̝K;Z[=ub<}֤x;qˉc;|^tO.ЊiA3.2bLH#SUH^]qew+PO+J+zxOҤgAT:WwpZFJkH7 FW-xJMmUTdL%qZwUՄܷar$g%wZ0>oAƋ
N쫬L%(qZxs߈2X
,hAVFw#;A-`h_e*SӲĻ+!y3JEO")x7s"	X
0S)KC>\XZ/,7%Oo/!XYޢyכmz2SKa>S"7	px T)MWBЁL%1qZjZ"w\ABaOɢD;;)\6uoUMVz5A)<ʊ/,0-
d,ΙTЂ׏+C<`#^)TRQag&A0g̀|\,()NO_\U"<.9S"F,KFi^(y^ר%Ҽ^Kzi^D/yBV赵Y=?wb<&j_nےj5{!G@O>
P~-!sEpg1.1"}Yi~n$_q,>(]3:XXPL:)6$h1R2(bG9
 	A͜ϙFU39s!ʹ(+@XDԱ=Dp|^Odb]0
0,0,ށIJ;bsrQMʺgwmne3gҲYhYٴuϙC˺Υeݭ1D.1jJ{}h`f@;s!0·!seü.e3l
!3sk<߉	|@LGwy~=Z<īIٻ).WAOlnNȿ!=eT XyJA^yJ+B~QE,h~j"L8JXwxNW1Ap0_5>xw"^X*m0O*[Nk##"AvYy^os$ǷyB	^QE(
S	{#}JDb~pu1`v n"VXfzS{#]="/W<"@5{5TJ|:$
Qĺ` «hp岣(b,;
ˎBƲ#Y_~4s&]~4k]~4{6]~B͙C͝KGmmd@yk0r2M-dRر_g^$7ݽ{2pi_YV!j۪W~y	Tx'{'R4
`t|kGV
3+P_wh^&$5"ýGŢk8S0JQ-/JA*FZ )&\J齢5{ǼJFbKVk"fBED'bpWi 톸OATq'xEqyGWX&̊˽ş3qC|g+{
yUjy 6ql6y=xEv!F|Eg0.ARÈĿ(9"lg!m8｀_\MaHIg'Jpn†s3[\-jBPw-8rŻN&ئjy'tA,^	p0W"x{_A=x#)+2v5W:-&ݻCul)P^EIi߽O޽y26$3DO>_Ew-36.%~ݭ)1cynX1熍!cy.Y;sLw,LwlL.ӝ3.ӝ;.mmt >,?U,B7[Ĩm䅻Xݨ
bc ,׭o_!x\gd
l!i{,VMyOVzKJM{vaZw#Cr,f0ܾb~QU?ӤgA}4gP9Ve	nz|S-Lj}}}0˰0+
1Wk|+y%YU-:20/6zbHK`tlqGEo+]x59ֵ#C;W$I-$b^d!ψBo4#FpjnrYcߧj9Dh}}uA/0"U_*꼃_)4*w=0l
V־1?ch($
l`oy52(Y#6lGg~Q_ܗ V3]@UX@^n^n?1^qAФt$:iɐ7)-mہؔS,lBϩCoSEyeʝWIsE`TM$u0C@m(^

ysi!xwE@W=;iaMMF7K@^؄LͲp0$NO+kCw(bmz`iUq
[h!P/+mIzȝ0W?hso1ϣy\`,Q!xӷxa
ž%'bzIc1 T^r|b]00%ݾ*VqUFh5ZeDVaUFhAZf̘̚=hi-3̡-3Υ-3Z[iˌ6|2,-3.=[BŨĦkarhF;G]gvZMkw
G<1x~)}JPꊢӡ)SRd2}@<+1_^|FIVȑQ1ΦwvJ']L90&	C<}XxT S:P2E蒯MqUCTjnU,C,UFQe7(Jq"qL-;8An[E6
AqUEC1ICI{'sylVO̰ɥTAHPl9*+-2ť;MXI(s	s0W2b6uviW8R|RYgaPo)m2JŠGNZO%I+`Ga
$%sFVn11Pba*iPrDHblQP/D/yGYew%_T	0&bkambUN@r;^E~bb]`N
W#F(+f4ʊ"F(+d4"
ffІYsІYs҆YaV[YzK;eNYaSip!mh#5Z©B)_^B+lowTP#ÓI]g`CQVVs%YR*ǺZf+NT9j&,-[w->coyDb\܊+FNNĸq!E` O|QJQn+41%
:g~Z+ۈlò]pgGZ/+Or;Zα%7:^1zktYDaL_Ue0oytVU/$aHʓ*O&VGl&gß|]y?xs"pTYd+h5FzoTSy.1˰i4䑬ș\+$[@w'0A-΃a1Kϕ{u(AXQTy
sygHfc,FzcT^Uy51۰h&+?mj[RHʛ+F,~lYAQE*=5>-y-*
4Y4Mh+!86:X)-j<{ʧ,/[Z*qNZ6k\cG
>mP)^
B"_B}-
-IbMN@&m	L됟17aR (~R\M?TEEEDVyI;ɤik=P+mBBsuo#>\.wҜ\oUML3lA=_\r:9~™àf0.k.tǕ!vw^//.y=*H"K`gD麘*&6_A}PA_U_ӼJ#JWiX&{U!}z$
ڶUxNN7f1[Tʐޘh̙0sƍƜ11gh1sƜ!1'iҢ736;6lm
:Ȳyڙ3w9zgNҠs"ڠsb]t1cf5䖝	GՀd{#Zd	%#j++%xl2+՘-Jn dd0Ymm^[nZE,!lz,HXχAQR[ҿ3ۼ)N za{Y:B
|(n7/EbzLiUPߗ").vz
^7:"Z^$xk_~/5!URBષ9B|c4Bn~#]S2D[FFxh=7ZnjQxh=6Z9zsiVڂǣz{<Iŋi%KXt3(=IJXGl.IjJ
䍎uU'<\E/HRn)R\.}.Nj\
еkC{\+-X~}o.]f\"^<"AXԃVK3/ҝHu]VJs:u_ӾJv0z(@j=X^\P#|OD*WYyB-cɄQ,Hj
Z_Mbl>SIQݣe-#鹖]O$n)_!2[Jr&*όA?g"h#-l= zb>Ql>2x`	&##%Zor0)YIXRIaSmI
CRkCĦ&`ZX'sJN<+:J;L4
J
mP@EASDz\.i%"~ATsg.&c=
P3deN#[p2ۿqñKZAStYQHrVlt*T8OѝlaH!v:lP/(c ?cVSCLI§y'[s7ztb.R ԑĵr%H/p8S1U2(FNtCآ& pP@' ?·cfLEaIbD'ۆ7*G!f~:63@G*A^p,V϶p(XZrT&$tSퟏmPb(DZb.6@]
}#]u V	rPIH3OW"u/FRR%E:
R̝j:<\F)$)B>*Zb~	)nobZW2܎'UZ*.[we	ҡ濅H>,AKH1-: o	a_م`7o]ȑXnԷsۺ\\v.qc;K%bl6s	۹7wKk+֥\b~.Q}?KXυld	eR+~y]w1nKgĦ^AcP0g'%򦃷:\.\f@:O^L~X+[:'';MSR y/N0&D,/S@Akn
>v$O,bQ2!3zb?`/r)o|#k\AȱHFeL&o<k47fRS
	GS!udu/+:faDIL΂iBt5/_3~r*
Bj}`+/:؋D`^j~6!Ou_bPnlPVrKŒ]˃ԭVuZͻk	K3InYټMnBdVE[PPCP.IHU=¼֧yUsO4
kK'DUWVWӫǦ9dF+'z
H$dRfKkf9!쥺zK!x>0)+$;5(RcVu-KKϝl;f.UPc'mN
ǂI4{ԭ_gҲĩ[$d3sy|W'=wWP(^rB&4xwރ׽#H:KmY4Tt.Fw%y	C,aޡzGb`s+JIR9}ǞԱ[8vѲ+9^jd52 YfR=zC
ꝥ-A$(yH
Taq^ɒ"$~JKd)Pß
ԧ6
Y`Rճ-fc3]uoZA\dj%#QJ^d1_DyN%DVr%uAnN\2'cAZHjF8W-fhA	"teAqIR2ݜSA%%ThYؿtFϰ ""Tڃμ45HP}"V<|RoR]E:Gj*ڡR=RarGZ4ϼW(HWU}6.Sإ"+.Wˍ̫JtU]v5h;JI./kN6/'w-ͻ/r$#M|ts>)_)_ؔ/nl36EMƦ|!cS>Z[H)+_\ߕ/wE]|dsK|˖Y1/!u3Gl:-Kޮ/n߮OW@&'$҇O&O#5QT0:__~g~Q"_xF}}6Vji@H$o_~asxm9q1qoY8F@#{"?Y5`Ezub#c9[>Bꏭ% ޒc˕,J>0B{Sl8[N[%7w/TyB"$^viaڿO5m=r֓#~_nS_xsW"pL1k& yM~&;cMB.GVHݶFr(c}ޝMXIf'oU}F~~Cu')$:a^3(y-caΨUӛ#X@WA%yU,Gv5Vnt~EIQI-w[ʖfp~ՠ+LB/nPn_Ske!^dTrPv$l,x+P3ʂJ'siоj"dBͰėؗ1/+^B/nu;D:kD^4/
-tyHiٚ88A4 ${b umy=BtEhG'[DzXMXNw pP\W\'xKR
$N65
5W5lO&7oJHmx3žHݥf?"]ܗ(1%uͯy]\٣fO2}L~!%$S)"uך,y4ؼv1L._shf:h u%U$`iFn53-f(ѻTTRqxb0Y_ZsD͑dJjSRhRlRZ6k#uT)R:R^=
kt
2y-ÓѠ
z+,{\s,R9bF&$5'3N푓eڋji$<͝vRR=]kNE5Y}!N"iD,H͖+t%5 9xB<V2`Eț%CĚ?{2N3j$B"H!4"`WHTs	(}Z,eXkES4@Pf4/n^2Sۦ͘iZ-?y5Ckm۽yZ3vهu)ASZF6Kj3y';)?훓"h?%ƒJ)ygOvM8O	nE'YGm@¸c0jEA¼GCi"c%
1d '{G`'40阢fDɮ..9"[QocɤN%	?+=fGe6@Inr-	gwzRHk#;}BU'}{_K&C+%UdfFl7]%'5XTdi4F"#N-29=9>x3Xѽ<*zW9'PgmO?X@PZ`piF6A?x4J>
&DV5)|R'#'12-c6·%V!ٞ#=μcqIZ'4VLIei6os2AmW{VOJպll)%RZztVliPy]J;i~m>j3v66K2/:]7uzC)6My_0"
[DJ==P9ɒÊw{&=ҮO.UۢNhq-=dR=&]-H_|y7Qüeiލk;UDndžIUrbD9{OU&U]k˖%[ݺ4IԓM[)y#ǭI2O2,=YiY:{^f˽$L%=>r)MJfBʖKV+yS150i5S6fg_iFe٬I=.um^O:qf$rAۜ/NaPRYW]ڦR᫒2ߺ5eaTBej.z^
K8J(~d.)"YX"}Th+z.ZɱelW[U֘1]U4LA}h䖒$?oeX45HU@UX7vg-gG
S0ab!d-)gkhz.`mbK^1zxhP"qȢܮG hF0Xax{z=yY&?"MJhzþ~K<Gbw#aL8FUUbaKͣwYhT#mKm?Ggyo!Έ4liؖ?J>BZyaUJyDz|[z72OРKN;iNkmŹK/Y4u%Xʀ.޼Kcy:uf3~K-iik>eqϛ7TbCgC&c}^k˼͜J?:2eVPTV(j-;+5aRq'5c>8gK*@!N
CG܎4tP~$
[F)Jc
Q6}ڐOP;W?5^i2"W+oQ8~GwwZ-e
q#)Jo˝z[QvOSp'>>ܙn#;p{({QO7It_>?:=}&w:D
)H0IG!#^kpfyO< v2b'RNfaI:!CC?_ʑOe[g,/v*v*v*TCNj=_nY:L9#n%_5ʬ<'fyrssssh#cw9AJ%n?;_ʼͧSSNm0;ws>N2NOe,UZ,JNC}}(˒lc;
vd+VH9ل{a8aգcO]a"SuSuJp;ӓݢmY>NYnd,?=))˾kӓ򬟼NNNNNNޛr&6ଟid}?1gZY{ZDߵ:bSubz[(
g+(29$|qЃd8T`*Y0,JL%SɂL	iI@KT.
 ferPfECqPz(ݥ]A͠l5 -.(]4P2?%_5uI8N~gYp~gYp
oabԮWn0P8brt[6@[n[.}ZB!ȥ4ś
o;9kpԃa8ְ`kX5,l
[Âaְ`kR]f iQG@Nnj7zx=T/իJ݇_;}&
6QWV(?rQ
\=	g=Zs-_˂eײkY,Z|-_YӼ	?j͡M{F=Jz:}~萄iA]fSO+,x
_ІYX=dcƒ1%cK0a,X2dcƒ1,%Wx]]LfZ5Zyss*]Ƌ,Ma]{*,~=ݠIYE8[y
K^U@,YFy/'zrOXrXrXrXrXrXrXrXrXrXrXrXrRs52F0kW>0XN_V>ٜx)kOM
KMCnp$=I͐n3Cʢ
La"5WI<ғ5hK,Y#XFd`5%kK,Y#XFdHISj]7YMO
Y|9U*S4}מZZ=UݷݐI7M1[ʲw>IQmYF5gzYYYYYYYYYYYYYYSeڃbn\s^Sw/rI@ߵnK0=ukI&ogWOv7[(2kC=GdbŒ9%sK(Q,X2GdbŒ9%sK(Q,RGeÄ: lGz'
OVCTޯ<_wcSI
\
h2wG`(儥Np,ce4A
ZUI<Փxېcm$:kNp#:ˮaSoS;vZCML1j(Bb}h
Jⱞ1cXǰdaÒ=%{K1,cXǰdaÒ=%{K1,cXǤ${m#C	Ǭ

8n;϶l57y1^xEޱT׳T멦:$}kPgeDt΀3Qk
Gu͋꒴ZaսFTϤFu)\ƍJbV弨nJ+XDڈQFu}T,z-p+/ҊjETkMAXÍQa~TüK+,zĈԨQbիQ=ƏEx[iEETQ=7"'QwyQ}VTXDQ}_r>Q=͏+/iE"g^LWFjQ=ˏw|:(J9#RReBj}Tn^F:U/r[D˩Q
UkQGET/BƋjlZQmi+FTFPܨQ,Zˏ*yQmVT1^3z55QbծQjGu'^TծQӈjmjTQdGz/iiE5"Qtu7QXD?fu&/iEbFTFD~Q8Z͋괴:"wHtnTGuET:S=iEuETQ35KKQ]aՕQ}ď2u%/ӊJ>6ԨnRoFu}T[D	?ZVT[D՛Q=>ȍj=?5CM+G-`DԨSF}TXD?yQ;^K#F[V~`zC}YN1l;,&_hAd|(Y=NVU;g=}}8/w6ٽ!p%~G_6׊i.l~̗~}MIIˇqĔs+cVέ[Yʹ}o$mc0p~QUjmONvrNvrN7.tU7	;5Ÿ'@1;,t5oJNj3lN*]
szع{ع{ع{ع{ع{ع{RF1ֹڝ6XkfRڬdwݚ+*5qn
7Zq3ޭӢC:LFΉ
榠k(WAUA*Z*LVbbUتXlU,*[UJl:cAe:aжІ),lޱ^eyYp^m8~GiuFp^mK#86xFOQZbZ}pï-k~įz
V(FCSA+wPPPPPPPPPPPД{kJS]cuYƊ',x?ςZk_k4kx_k252"uXce8~%xj/?EVk򊑔|R%VZrK=71gr3f8p,7Yngr3fxJng,N~0iۻFp!e1]˒S˒S˒S˒S˒S˒SMbmZm/#9Frj}j]k箵dŴCwXc5	¯kïɔTk7?>56ҚTt-v$w-HF,w#YF܍dr7n$H,w#YF܍dr7ndJ
oI0Ҧ*]]uu=-cɫcɫcɫcɫcɫcɫcɫӦwtՁ6H^6H^l$Ni$Ne$Nmïu<~N$:N>U;(I9iuGnuXF,cYDz܏er?~,X,cYDz܏er?~,X,cYǦ>bC:;Ǥ?_@nvM*{fߠ	uڅF7h6ߠ]l$AH~v2#
JŨC.W:T
Tnס5m0_Eg.K2Z_TWj1D1%(hv5̄f؄6aMaf؄6aMaf؄6aMaf؄6aMaf؄6aMaNf{C,efͨ	xG/oyVkl=N=0p'	0p'	0pv~Gהhp8mN@'i2	hw{1݋Uw(PS]-u+~݆_*įn/ڸG_3hEE`[=IX:vq&8.ΰ38.ΰ38.ΰ38.ΰ38.ΰ38.ΰ`!lEf)J%D":[>`‹ʉ/0"/0"/0"S-מ6hEEg
"sxy^D{/d^VR*S [*%Ƨiz_s<~_/K2~_RQ^3DyF{,LLS=(;\EN{ŏ(WZ}J0&XqP`&	n`&	n`&	nB{L߽o>0Mh&p	?	܄nB77Mh]%}~W6
B~_ׇ~}_OSR.j$aO`žzuA.&&V?ob71M&~ob71M&&W&7&w^~S/0o7z2oW^}	]?O;Jckzdï_W"wʼnCpwvvSutssSrk@)obS-yTe3|י&IK!m4i-	@((w+PZrUvuŖWUWmaUunJE
"P{_Kn?w~}C9̙sSH8R&21,m,m,m,m,m,m,m,m,m,m,m,m,m,m,m,m,m,m,m,m,m,m,m,m,m,m,m,m,M,b4;Y<Oivg4;M,fg)iVAuU%Q5%IP߁ZLFutKi>
ҧ40`|O}h.ק}85)8<)mcQ-?II*ᴧLLZ[ebZ.Z.Z.Z.Z.Z.Z.Z.Z.Z.Z.Z.Z.Z.Z.Z.Z.Z.Z.Z.Z.Z.Z.Z.Z.Z.Z.Z.Z.Z.Z.Z.Z{x_/:N~e,h'49밸?W&VHU*jqZE\"VWU*jqZE\"VWs2UNaq:],Vbq:fq:=,VjuNcq:},VtWsgq:b
*QJ5@LM޷d:Nn:Va:zT:N8t>]OEIΙKBķBķBķBķBķBķBķBķBķBķBķBķBķBķBķBķBķ¹1.bp.fp.ap>[\[fpŷosos9oy


,Y|+/V8_VCu%Ue$A}/":.:}Oi>
ѧ4,P|OӅt>]RXϤdpnH6;dbmv6;DfhC!mv6;DfhC!mv6;DfhC!mv6;DfhC!mv6;D͎4m'?B7O4otnғfIN4`lϗs|\ussssssssssssssssssnfqtnaqt\\eqtncqtngqt`qtdqtbqtfqt\|ŹҹŹҹŹҹŹYĉ~QjZ`ut
7qߢV:qqwqwm:C=tK}t~:cR}DX]ߤdp6LZ]2vvD].nhK%vvD].nhK%vvD].nhK%vvD].nhK%vvD].nhKەxg}?~i}“nUAs
38:,S>Q)vx;E"NoS)vx;E"NoS)vx;R5,N'tx;GXΏXΣ,Ngt~t~t~t`v:;YٙJLGzvf$	2HбGұtS:0}OCiP>
ǧ4.^Mʿt',wRVN821km#m{D=vhG#m{D=vhG#m{D=vhG#m{D=vhG#m{D=vhGݓwy~w}Ӥ;JeuߓvPyX	{dtE"nw[-qwE"nw[-qwE"nwv=,ng/y
Χa4  ԤOX}dpKصdbD}>~hO'D}>~hO'D}>~hO'D}>~hO'D}>~hO'Ҵ_qKIov3ժYVc*Y[Ba]2{zE"^W+{E"^W+{E"^WJ7d{C67
{C7b,P{C1o(
,ސ
bX|ogF{C,ސzLT.Q5+醨pap	J@	>	2	&	@		Ӱ}OCi>
ϧ4$C~(My("`F<{_~7{_~7{_~7{_~7{_~7{_~7{_~7{_~7{_~7{_~7{_~7/m?zVtoṫCsrDh(//:QUuxѡ١Yy:P5BK9SUTҬPq[GPkC8?Z=A|,C]P[Ċ ˟~558uVl^g>ٕ}(t:;qss
qh`qCS/y_6leKe}E	\Ct?4ݹWXn~KO؟QP$tEG$Ԫ)ԻLrrN#E8o#k	teY6YCSá+lЗsR/(Ln`FF'wrIArN)Sezd(mnFI՚H&:7Ӈ釩aI@ץhZ t[5]A;IǍrG2_1x\E$= ]|cq)x]hk,.
Í$]J!ߐ~oC?zE!p-;kAXQ wTTU1u>/p9Q(>|uG,zK7%11ey_>:ː/CK&pȳX'u	u	Pn6;XB
^uqxG'X_?O{T+|{o55n$qu.Cf:d\i]L)8na%eֱrlT0,\TvN8>רo韇~Io*h5[{{=Ʒz<+7;xz"3waw=nn'{(}ҷؚ[Xӓt	Oa.IO8{BS.٤KҾK|y?+f;Dh.2_`!.
.mX{qxo#&pҥNwr_Id=az'g": f(L8DԄC+pbjW3_yW-pSUp`:|U7-ΏFU7QLhS*76$AA"tPi4O8<
‡5l4uc˧n5f8;0é0!O3L&՛L\JJXߤgПZ?u"/8eW`EI/}&ޤ㯘Oy_KiA(HZxM9p ;!މN<@wa6LJ^vv͘áptҮ
Gϖ:%#<'慣<'c<%<%ݔ)iOIaYigEva2:\6%!NRHc̔sx\$$\$$\Oj'Q~61ɗ'1))yƤ))\yJ
O6S.SRB\4$\4$\֤LIyJrKd=~.B-5Rf W\~rQx_p.W\z
"A5"BR?V5-~/_q <;\×.	LaIRЫ$F50	C;\õ_^qWUz"9hu (cT06˃`	2c+?OO:k: s$9QϑzZk~POO^86F֧FrzfiSO(5埛e?Kd$?0=\A)CS%f?.S]'ӇMO,52_ SY2&Sd~_]DrA,], Uծ8SPΏQ9vq`< ۂBu>>_?^(Fc	AQ"|~GY3Y⑝s	
(](]2((BK}-tA~F8^	/_i`%uAX[v 3,`?Qc8U+OP	]p P狂">?QU
I8LR	Ūjol`UxGV~0.(&ʼnzFKuVau{*=ź-m6,#iQ&Қ*
iVphK
h-+|k=+8O~Wp-Pj/Z\T

ڤTE뎪7i-MZ˵пj^N՞md7[-Xk_dX_rnuYڹ#Vwh{dobwu9&YAt=#ݳd7D٨^iaEO@Tv^QjZ^򣻅LJc+	D3	nk$_s)H]By765HĥK#q^=62*e	u:/"aˏDEkAkG(\ش%T
PP%TdYBEp%%%%%PSP}"?2,CHI*}EHKKа





%i_cxه%T"-"5Pf	b	b	`XBaXBaXBaXBaXBaXBa!:P}ne!qdN6}	qHKK\бббKPK(%@
 `	%T//2#_`,,N_BeYA*,*,PK(@%*,
PK(%@
%Ԛ%T/48CԑH+
LuF%"+S
X9)449f2 A50 ))H1T,H.*d9I
h}1.Cܑ"&KAIG4y'"N"t@eZMT+@T+@﹊t2@
{
{
{Kj]y'ҫC.59AD#L{$|![Lu0(
o
IjW+p48F/dU7%8S)|TU
SՂ}*+Q)vAi"Oz_g^gMhj"º=vu"g奴?+ɴ+I.VxZk=+xV
XRlFN9D^9碚+s )?r:M>Zǒпn{ma:k-{,}\7K{o+9buOKS>;>UO??f>.
WKs2.Ŏ5qm*o*o*o~R씤l̼tx䥦[#WI-R#|<^󏏜o"ȅ'r0G.%lʒ\d>.<:Χ:.":.:>\|ڒ9}xZ,%xPA%y_ȒBY2_$K)KO%545o,o20A3rW9ˎA-ϲd[7˒Y2_!Ko3eE/!K/Ȓ\%d,qJ^2mw0j}%sZ2?eɼAw˒fY2_#K+dɼ)Hz|,!K/Ȓ\ %d~yMʒfɼ	7`?N;D9=>lG
zaGi)$݀ݼOȯD̡A|(;B}ƥlΎs97d;67dQ̓lEVlcw8xȋ-˲zET-՟dK1eKyRG
vt|tB*TəTB4RzlRHzKu@TrT/˖RlNR][*4x!hItJj'm32ofKTR*zlS
[*-@[MhzKl^1[*l̓T.Ok
z":3}K5T9TJtR:lTNo1[, bKRD: [}X@[eKxʖs37kp>ZdGJ[[hRJl%T[*@-[w̖*:RTl*T[*TdKzK&eKϼ!\xyT5j0:mI!hQU2U6U!ZhC
Fw3U9jZ]TZG

 R {
IЮ'=~pm?MU
Ӄ8LWg3|f*a&A~uS`ZPj[gKi$GZCSD3pY(Y(LZOQ(ZQh'Q(z&8
?Q(&_dGh6FvGpPn*Gpw'ۋSB]{ϼn>ku1]֨Cm|c5
:phIwPf@rx&'5=	ܡ9jOnss9CFc@Jc@aT<΁@j!yv1܇bǢg<)ZME[9A|K-zQL `(zoы-zQSc-;֢9a+~7lE(z.Ol=z&
tE'gq3tKy%Ϧm3;/xf~٢GW'Q
Eآl[t-:@ `}&KiXP ІLK/mѳ9j~M-ElѣWGQPL`PE(آl
[t-:-f~%
Sq aomѳ;j~s-ER藚-z: -j٢ɀ$l	[t-:@ a#'y~٢_KC6\74й%-ڢߝe~lѯ-ElѣkMoѯ-j٢Mhآ4l
[tSכ-4d
26|N}@GCm7d٢#[[e~lѯ-fz~lѯ-j٢ɀUDl"[t-:-uf~A
߽C
Iߢp-,[٢*[ke~l/5[Jke~lѯ-j٢VTl*[tE[kVf874H0z(%}>㡶۲l([٢*[ke~l/5[h@[{eV*٢-h@ -)[o-	l><4Pq}ڢ̲El([٢*[ke~l/5[Ojߓ-E_+[d~lWL--7'@pthXqR/"#IDL1΀z@ЇP]ˀKy^%^fk@^$䡺	>Ԁu?54,P94
ؐz*So1=YI!)3Ԃ
OZPL@-	TW2"L@-HqQ	)P}	)2 e4W"Eݹ0&QuPq8?$:~;4Jذ}
w	jx1G#܁?r`ײ} LU˂2>ڕCru~^jW_P+
>?SU
A%`RU{q:֢Ϩxc̠*}IZY
묲ZOv|Q}7B:)G_L{u3A+XkWնpMSpMVpp_5ƚh}pڨp!;\/
pFP]kc.U{CO{]_5zWujCcw
2W/0i9:j4pn
Sͅ`lTS\&OxJP}Lխ<υ`bdl.pÒ2>pÆ;boDlzVL38b%ZDo'6)W&EbhRm&EadR;$!0)z
Ix;)7No&EXDM_-Um:
zw8H{tx,YD2AO"EEGVPEWhmXDEtP,"`&`=.haѱ4(cJĊ2[D12r@(6=r-7r-"z[,w": ѻb=XDEDCHIi@Zeb(f^&<P"3@,"-7M[DoEXDEt@,w":h,":"}xi1vl<"QQl,yqE΀UDXD@ћX@[b-;b]cLc.?CPb ['b-lcJXDQ̼LP"0@EPaTmVTm%b#6XDEDg!Նel~!"qF'bM-cZXDE3/b* "Ȱ2,"-7*-"z[,wE#3"-"ޅCXth\PlN0EajXDQ̼ŸP"-c:,""谈:,"-7j-"zXD0:-ED½lk3؇-!9rDQXDEazXDEaV25 HE`XD HEE&^EXDXDfʡS
XW;"CMNlVT"@,"PT"@,"P(a&")@
,"")@
,"-7Z-5)lA)цiGR}`0`\"vV
!{O3!uFƄԁ\T:PB5	5Tc:PCQ&$V2!u iLHHG5	IQeϮ$)B@`K.Pj<
=:EP}2)g1v)>E)Nl&T٨V1A*	LP=
ՃczPCx}&y>ՃZcX=^`C[iOC;:h=e;phZ[iphKcφC[d¡`-v5/8"cOUZo|O	Ƨj񩚭o|cO}SUφ.aA{uKMkCNĺ
^!+egv8nv~qkx	NZ4ŪIv^0jѪ'l,'	Lp?5<٠۝niAVf1G,Mfy3FM̼&fތQ3oƨˀ׀mi>&v4KsXwy5^`iX &H	>4t;<
CtKs4'49ׂ
minKsXҼS,͗Z-ͧ|L,bi>$F4Kj&)4A
,Mɖci#Qkfei|],}biK|sі647A,;|	I+Sbi>&v4KsXwy5R`i$mi>bi>d,	ycxqp n99d4X#zP-mbinKsXwTҴX{|J,.CbinK.4fA4פXy
]
2sY0L:{)/CiPgz	ku0a
.j'"63a
.Nva&$z`@bLXHQ=Ƅ5T1a
 q,؃njh@p0!MB?TQxw
Я]9b
)V<	\*T3AjTQd(LBPGu'[@> 5KLB:SLB:v&p!HJ:]SBPD@??,:Qx!7 ϼb 'WiW
b>}W؋~ŀ]4+`&?T+J>?KU*QUq{UծF0[	jU78ɠVujoy N
}^kYAu0'Kħ"ոΪFS"_s"kZ/#u٫F"1D"Qm/~Db=
E"1eD"Qfm?Db>DھDނDZ`8k7$J٘OlT!N$fc>E:'1PDb6H|C٘O\Twj#~[E/M+߳_3ڞSe&і~HV<1̜D5#ҊEħ?	H,zhW o8EWdZKf1Qk>DX!:ks!'5jg!:"jWO#P'JiX50K_jٗgqQ$~[%jKّ.װ#]kI
֒\Ku籝Ug;$>ݖxCe*:z2kCG-s騣ct?>Ͳ(P:Zieo2}|)g,{h,{h,{h$)s6З1Lt_`e?p''g2=eo㌣ ²",{ ²",{ ²",{Pe$[t>k>: JK<?lǻe(aJXU`%@ePaTX=@ePaTX=@ePaTX=d	ùj)~zt~$"e-,{@²3U=@eadX=@eadX=@eadmO͖=
?CYO[CHDD̖}SƲ԰5,{@
PòWtX=@eatX=@eatX=@ea#xJŖ=
OC-!%$Ds-EƲ=,{@ò35 =He`كX =He`كX =He`كX-d˞gSe-!&&D̖}ƲA,{PTA,L@-HeR`كX =HeR`كX =HeR`كX E[S,`˞gSW_M쇜2[5A
,{P5A
,LHHe`ك$X 	=He`ك$X 	=He`ك$X 	=dlPz+~}t~f7TUA,{PTUA,{P>~T`ك4Xe`ك4X 
=He`ك4X 
=He`#J-{?(]7
2oߞn+aQY,;e`ك:X=e`ك:X=e`d@",{$²_l,{$²A",{$²AO7Ps,~_|]e?EYb/ƲA%,{P	T²A%,{P	T² U[7²²A*,{
²AפX~}t>kLG"ՋGA"𑄪>r2A&t1E5&t1
	]j#>„.1TbBZ y; 9Lb<{T̈́.cQbBr$/F$Q~ EO1l8 >H1^Kf7(JB^&TۨgAu.FPBy&TGP}	n1TLp#vQ5gPgA&&	ncQ7V1 "]ZފϞHæGç爜Two^S7+rʤ2闃2遁_d_5+$_dʤ^W|~Uu~4ת]%n8}0WsN19٨ĮS.;8B5N19EP]ĉ]7&pb׍E!N19B=%Q#t	:i"g&rN~n5¡\s<wGyĵ?Yt@{
?H
X/SeHQ=e. qdC)~>.,]T|\YBd%G?c<SN~oq¥[/gM-?FX9+3.J9*D43(Ɵ@4ߥ.lilϖnaiEvKR"?iEn:бgxx=E:WNNILDX9:Vu["=a9~/L4Yg4k~:FLMK?ggVJa`%@`%@.vKG"a=#ֳa='a M 59zDX4mFT\IO	7#,OVMdE*#a=̀VdakDX{$+3a=+sa=/&BКa
7AWwa
!!
nj#GXovMcu7VjDXWta'~fvI["=a97%h0p#\0=RbI%#,70o",7$A^3[Ā׀DX AGXI_"#]akDX{%zF"g%zN")>hX~E#@4=bM
RaSMZ4HպA6njA",	)@
",#,C_Rt4PRtK"akDXH&GX/rE3Q62Jtt+#!'[9rg 5@
",P#af",	I@",5=uq#_t4RtK"akDXϘAorh~VzFF|ݹn]z51pgy&U@",PT!U::(k&r뙠z!i\_遯i:z	i:%nHW")9¢AU?2t .q#a%ۚ9r7Ca:DXCtuP"L61a
 HDaE&@ޓkDXO3a
 QGX$-a!(N^J_(ԁ{k	dPp3GXraJDXD*aJDXA^3	\RaTDX HERaTDX UGXI_" UGX$m",a\12Juvְ H#,daZDXEjaZDXEjuuP"L„.Ɉ@2",$#Ɉ@2",$=K4$kDXDXqECQgTk	ePp?9rLajDXFajDXFuuP"L7tDX HGatDX HGata'~fA֤DXrEâQiLD$&Ą‹Ot?7zLxEu<Cf1M>*`›@}U	o.ؓmrb› =jW	6ί	
A_B??X/
ŪjoX%?XZ`nP,'/{:k:zع{)ޣU=pdػ3ܯнj}		{	xz	\z	xgO ڧ a?j߆|ކZm?''Z3	kb\~NoT7>7Fz~jߨ:^oTUFT=Q|=Q[FzMt2=Quy2tb'g;֫9lB>*8D8'Q.n1#	I	[TгH=pr}#cH2E|~/psQxBNj y8^PM"EϏEz/pP)".WGNor{"Vl {oj\^Ǚy{=ge
7r\	f2f[8p+syP{+AeZ'8(sogw̽2N6cܻm#`:z:nF:nvtBǷ踕tFtAǝtsץE%JO9vMq3J"*"`"*"`"*"`"F#B\sOFnHptxkxZ*w3gU0@FdD0@FdD0@FdD0@FF1&HyGiPv,Ke"Mpkomp5@zuծyok^[Vuծyo5@GtD0@G!)m?JprnhxH3K2𣖉715.R	:,zu5y]pk^\׸u5 0H@D 0H@FضLK)_N,wX&~2&&5tL@-H67KDyqk^G\׺uĵ 0HARD 0HAF SxrpC]y%m	D;,?jxRj{:#oxD#;uyqk^w\ׁ$D 	0HB$D IGS"1n4={FN7LCz<^Ef_L2wX&~2&&T!v1A MGOJS"mo|5SwA"`!iA"`L"}#*쾖+WY"_L2wX&~2&&!v_g@HD;%&fGj\$"A""`$"FErGN!7\H	kxe"-Le"L	\* UG$#xD%^o"`"A*"`xcJ|Dyp/MAs3Gc]D-hxe"',Le"MLbP1A_xD{$~R"oxDMdD 0HFQ#9~#`
^h
FG#H7.s1ZGZ&oED-?axe"G-obA5"`/	n:>(xDOJS"moxA:"`#鈀ȑLw)
xoBz6`Jo>rQutJwrH{pE-^7w{C0^^/ީ{qWqWQwGG8(9(>rq\xtBGttKǩtFGqȳ=----------------hJn-4p 
D+Z.Ix_r}h{k/25 -ySw
H@H@H@H@H@H@H@H@H@H@H@H@H@[.傆_<:
t5!vc
[.3--yOqw
PRrRr7wׂ\\\\\\\\\\\\(A5GGn@nnJorL0.ݞ[Äԁ\\\xuLHHBHBHB˅g]rrrrrrrrrrrƤ[.h~=7EAɻû3b12\xw1A
-
-
-
-yqw7Trrrr7{׃4\4\4\4\4\4\4\4\4\4\q)ž-4h?#]weɻ[r1`B~&ԡԡԡԡԡ3n60a
 - - - - -ywHDHDHDHDHDHDHDHDH-)-4|?+}B=⤖av̨NcnLBPPPPPPϼgxgT\T\T\T\T\T\xA*Z.@*Z.@*Z.@*Z.@*Z.@*Z.@*Z.@*Z.raGGnL/sRŰ;hTϲ\Şl^jrjrjrjrjrjr
/L[bϴ.hhhhhh̛d\d\d\d\d\d\d\1*kZ.h>(ێb 3I-#Q-tR7z3ԍ------*Ӗ虶Fϴ%6t\t\t\t\t\t\x - - - - - ]\Ʃ{iAtGG97P3I-#Q-Ogi0MnLvg:@=Z.@=Z.@=Z.@=Z.@=Z.@=Z.<&&ϴ56y3mMiklr"@D-Z.<&-Z. \@hrƪ\;UTGOrW,niukuPElv̛]*W7ʽUMrow{ӿܛ]4nS(uRBʽUЮrv{-k]^*ZhWBJS#uU%zQY,T݅UR`V
X80+I ixuE#pTE;=Pͩ/cȼJ6d줔G
xI0yovT.Gbll|QdA)[!1BZPCH}iA!-(!>܇҂rBZéQ^6,ecvYJ2Le3b1EvvS)6 N>kDjB&1ՆNٗ2bŎc.V'I]Hb/ŦP*.M_䷱uغ^]X^]ln.f?o<_:^XY؉fԚa^c8ڌ:31ތ)f/fF͘ay48XSu(ƙ席s&JTl4ψ59D(Q,:JŢD(Q,:JŢD(Q,:JŢD(Q,:Jؗkٌ.bbJԡh:uWbeg(Q1D(EPhJM@	(Q4%&D(EPhJM@	(Q4%&D!+QE2X	c=Jԡi:(DN̢(Q%*̢)(Q4%D(ESPh
JMA)(Q4%D(ESPh
JMABWfe.PڑxK ;=P:dCMZ\̡5(Q%֠DVKC$(EPhJMBI(Q4	%&D$(EPhJMBI(Q4	%&D!+Qlje.UӞoc{[uƚ{q%*v4VD*(ZEPbgKiJMCi(Q4
%D4(EPhJMCi(Q4
%D4(EP󕨙DV:{-sa
2lŕ؅Ұ&ZEPhJCu(QwJÚh"JMD(Q4%&DD(EQh"JMD(Q4%&DD(EQcE2oc]RDѦGgc,D.6J(ZE+Qh%JD(Qˤ4%DT(ESQh*JME(Q4%DT(ESQh*JME(QJQB󲁷	Ů,Tp:pq%*v4tE(Q%֢DZ(ZEkQbWKCd(EQh2JMF(Q4%&Dd(EQh2JMF(Q4%&;%ʊJtQ̒ꁷ	n,TxcOWb-%VDj(ZEQh5JF(Q-4%Dt(EQh:JMG(Q4%Dt(EQh:JMG(QJT(QfqA}['c*QGdlŕmVZEQh=JG(Q%֣Dz(Z]
(Q@(Q@(Q@(Q@(Q@(Q@(Q@(Q@DM%,:>pLB%8=6JT
P@%
P@%
P@%
P@%
P@%*v(Q@(Q@(Q@(Q@(Q@(Q@(Q@(Q@(+F+QSE2{$c_=PD!ecY\=(@JhDJhDJhDJhDJhDJT!HP%
HP%
HP%
HP%
HP%
HP%
HP%
HP%
q2_"JY:uXx<4pD@J쫅J9]}*(Q*(Q*(Q*(Q*(Q*(Q{T(A(A(A(A(A(A(A(ABWE2G,cf5 *Q+D`:A%
tP@%
tP@%
tP@%
tP@%
tP@%
tP@%*-P%
P%
P%
P%
P%
P%
P%
P)QVW%,:"|5p~J:Dd?JP(DJ(DJ(DJ(DJ(DJ(DJ(DJTPPDJPDJPDJPDJPDJPDJPDJPDSDy%	#G	ƞc^cN=~&@uV@
ZeT
PݠR&@unJu
ZéV	PݠZ,@uVȒT,E
d#nlT7iw
P@VIZqT**x*}w#nNChк,^18Ğ6O4SP/]`k׏ Z@jeT_z@-G!TPJujéz@-Fuj	*zQ

`=@zTT
`=@7&P]&X`=1s]&ɠ~Yl5`^8r"x>6xː7}$HG$dt?29GBp#!H$dp#!|W|;ߢ[d~2dt_hmX{";߮e~2M;D/N[eZt)z!	qWDGE_T$~Q}<}>>X!G
Q*L_LJ^}JcY]f6c{#|=̈Qf 3B31Čj03Qn+ЌRyS*c|ό'>&8qw=WʂϤ	(4ő&8GHPi#M@q	(4ő&8GD|OeH%hz:Whc&t,>i,ݡW^q+
ESPi
#MAq)(4ő8GHSPi
#MAqDW{Dq4hGMiZ1ЍS="Y\qO̡5(1>U2&8$8IC$8'^iHPi#MBqI(4	ő&8$GHPǓEq4rZ9!8~\|Vx7W㳥A
őV8*iP#MCqi(4)}ҠFݡW^q+
ji(4
ő84GHPi#MCqi(c(>S9a8~b|^xXFWaMő֡8:GZo5DGHQiSaM4)C8	WDQi"#MDq(4ő&8DGH8$|UоҴ	B0
U=:)8ƗHi%#Dq(őV8;4ő8TGHS'
lNqzqOǽfHSQi*#MEq(4ő8"+]8PEY:8~JH;+{v AqGD|q(f!qyiqBtՅX]X\q_#t
#8
#8
#8
#8
#8
cZhPhPhPhPhPh'tSw^qzq4Nqt.YDuX\[d0_PqgW70:(:(:(:(:(:(
0@D(@D(@D(@D(@D(@DNq`:)C8	h!BqDWhS6>-
BNPq!+;.PBq%GPBq%GPBq%GPBq%GPBq%GPBq%GPBqJ*GBq*GBq*GBq*GBq*GBq*GBq*8	@]@ݡW-T(c(fa ={zB6@q1~
Z(Z(Z(Z(Z(Z(Z(
d(@d(@d(@d(@d(@d(@d(@>Ȝh!nD|q(f 
&jq1j(j(j(j(j(j(j(j(/
`=@t(@t(@t(@t(@t(@t(@t(@>hE|űUGj@}49a;sZszb6~Lˀ^@u2T
:GˀPe\S2"e@/AeST_2@XAY.i
p IuT
p C+ep,U*\,"=1Zj}4:;x[6$s␔ȃkbw^P{ACk^PBuC{Aq8cT^PLPM{A1I(ST_{rէ^Eu]`/PVR{rU@9BYCe;K/wm-I$8~4H:;D"|ՀUt#ul d{;d{d{tA>|d7%d{0$z!B;ߦd~2f	nۿ|2fzԝ2V.UΟOn[eNBgч8EC/Ϝ>HHuJ~K.*rQYswGF>!4ZyC#''f''jLuLu*S-s{=Tݞ`nO0'jLew
'ݞ`\#y'yealtp"##FK7Q\}SGTɶ'18y:޼7E:}U;/v.9䋸o˫"n2Uj7PHuJ-BuJ-JuJ-NuJ-Q-WE@	*(I567}ZMv(6y){?ifnrz,9SS>5R߄Nqm۩߅ΰ}Ωm:ƭw+_lj|gS㯉45(DvSbj|j|jp_8o5k3^27f֌ߙ{3x͌?G3dƟ;xg̛>Hs̽?-fV~SJfgLSPi
3MAq)Nqz+ί^q~5+ί^qC?^qS?^q	wf	wn%k	LJzD6+8'G?}eNbH@g$8o̡I(4	ř&8$gL-ˡW_	jW_++W`A|EqNXQҴ'1t-rD<(P@#Q焒5*8ˇ4/)
jiNqMsViP#MCqi(4
ř84gmW_JWC8oZ?^qc?HP _q~(U]ҵPq>,#]&&WcaMř9@SRDQiSmUDQi"3MDq(4ř&:y[C8z+C8zW(EA||Q}WY@A&1Pq>LC]&WfZL+QiSߐw$i`3MEq(4)ζNq*
l(4ř8TgLS-ˡW_	jW_lL _q>OgJR8HLML+TX:]\qN4HCZgZLkQiSߐyy4ř&8dggd8oΣ(4ř&8dgL-ˡW_	jWmQ	"+lDmҵs*G`1sQBQi53Fq(δ)owW--4ř8tgLӝlLQi:3MGq(4)B8z+ί^qMGq&8#YvPB%Pq>"]WfK+ΉVix+Gq(δř֣8zgZ7Bix+83838SNS-
og @qg @q8orWB8[P	2+glIK4$:K#4lbYq9%3(83(83(8Sߐ%Nڀ(P(P(P)C#ۀ)οڀ(P(P)B8zBL!_q>Kg`8T:$\!ћ8Pq>b]&(8'(Π(Π(ΠNq~C~֞8Mhg Aqg Aqg Aqg qs_D;8	38	38S^q8"_q~(f!qZqĚęx]MS\qN@:@TPATPATPATPA)oO`;o@:hPhPhPhP)}W
 @4(@4(@4NqР8WMgqyKqĹ
z|6qQq9q	:(Π:(Π:(Π:(Π:(Π7G0@D(@D(@D(@D(@DNqU"g Bq"g Bq"g Bq&H8Ugy{rĻ.Thlb]q9qJ(ΠJ(ΠJ(ΠJ(ΠJ(ΠJNq~C~ӕxT(@T(@T(@T(@T(@TNqU*gBq*gBq*8۠EQª=C.'_8ؘk+Ή+nBq-gBq-gBq-gBq-gBq-gBq-8!DN|@2g Cq2g Cq2g Cq2g Cq2g Cq2g ss_T7838}wW׊lX^(b.6q]\^d7W`=j(Πj(Πj(Πj(Πj(Πj(ΠgsPPPPPPlsVPBLP#_q>SgqtȹF⣉*%1ls.z(Πz(Πz(Πz(Πz(Πz(Πz(Πgs\QQQQQQQ)B8o2@NqA|y(fՀxtħ
6✸SEgPDqEgPDqEgPDqEgPDqEgPDqEgPDqEgPDqE8[Qw	@(@(@(@(@(@(@(@Y͙Z(UJ8۠G|(Φj8U:$]#
(ͩ./q'e
wP"@.2+R/@.!T9U\é#@.`r9h& ir Ar9zH5ir Z(@.qT@:R\,5t"A	LCs5h1ٴBK$xDc9ڜz:D%ԓz;NK
P
@Wj
P
.@W
PJ%T
PQ
+@5Aj]_@Wm.tЎA]#1To@WX@[Euh&	+*)ZBkwE&硺
T:4E/YI|=Q#z#V=&D_VGY-¿U&D\c|؄qvJWx[elBt'|26!'D;_ke~26!Ez?Z-u؄;_e~26!=OdVa(=3dX[elB@L;>Ng*c"G϶s?Va3ΟO&[elB\;߬eD[elB<;?_ϗ[elB9zoխ2Va>"Hm	ы|%؄?֝v~4l	'n-'*ԣ{NS)2Ui
,#Pz299I)Agu>Q腺]/]d&B%#zd@s%iɕoJ>'?1N&&]ȋ$L}A@¤=Ԓ0Yl
0i	6091X'a
D`n3&`'	c#}QM¤!%LdJdSL&u
+IL~IMdU$LGF_#a26RY'a!u6S}m0m0m0m0m0m0:m0Z6S-wS朂rF9 NU62(*62؄s
Rco&+"ӣ7+N/\X6?XAȨ?Fz<<4nR܉>9}aRtd7H,ZUny/#OXGEUŹbnK涘[Nys[-R]/onņP],onņR7bém1XQs%jm1XJɛbn1涘[̾-&z~4J{)'?~U崯
;DN?x$!9tSˤ4$~HDC⧡D4$ߐY3?ݐx6tpCnڐUtӆsb'6$ؐx^䵆"5$^!U\įEeiH$*KC3?D$6E|ʌS36gf	y%3~C#^IZ8􄊽O/#;9	HfiD$&ID"hD$&ID"hD$&ID"hD$&ID"hD$& 8|?׶|͌K q8ؽHΈDlYcDئHfiP#M#AӈD4"4HM#AӈD4"4HM#AӈD4"4HM#AӈD4"4HM#A(?qD4kҶLF{{"`ѣjHHY4@D]$6E"6KÚh"H$&D"h"H$&D"h"H$&D"h"H$&D"G"HʷOm Ha&ZJDafZ";#>]^pi`3MuTMufJ$D"h*J$D"h*J$D"h*J$D"&G"HYO;.*T0q	x$Bh-Z";#>]y4HMvdMvy4HM&ADd"4HM&ADd"4HM&ADd"4HM&Ap)?qD"DQF" dդU%
nD"h5Z";#>]^[xipM'AӉDtMwt,
nD"h:N$D"h:N$D"h:N$D"6G"HYUKrpRх#Jʬ^<᭴H'ADz]:F
D"HHE"6K[H"@@$D  D"H"@@$S~$jDeRm1Eula$1zlVP<f
m@$DP 
.3#6uD"HP
"@"
PHf
(D D"HP
"@A$(D A0*?qD"̂p\ip)դF"8!e,@ D"@Hh
vu$D"H"@B$H\$B">Yh"@B$HD	 !$D"H"@B$T~$JDS"TM-*D 1.t
P!*D"@H"";#>]~ ء @C$hD
!4D"HиH?Bx-H"@C$hD
!4D"H XD""Ceqiq+խN.D(Agi#G"C$tD!:D"@HHΈDl wSN "DD"H""@D$DD#B,t "DD"H""@D$\$#HYNuRZ\KPF"YR%"D$DP"JD"@H(%+.J*"@E$D"TD"HP*G#>Y*"@E$D"TD"HH$aVNJh+D8a'dۋG"n"ZD"@Hh-"E$D"Z.3#wZ,ȈD #dD"H2"@F$ȈDD#B,@u #dD"H2l&B"Hp:wHD	7&S<.z@H5"F$ԈDP#jD"@H5KutD"H:"@G$D#tD"HйHE",t.Y:"@G$D]5E"l+?~DVGۅE{
#%IYu="G$D#zD"@H="G$DDHEHT! $D"HB"@H$D! $D"E"HE"6p $T?2@H$W~$rDeWGߥEՇ
#%Jڬx$B])"P$D"@H(E"H$D"P$D"@H(HΈDXD^$D"HPJ"@I$(D%$D"HPJPHE"6@I$(D%au0
P"b#%txHQ\D"@HhM"I$4D&$D"@HhM"I$4]$bgG",D"zr9R"@J$HD) %D"HR"@J$HD) ui5E"6ˁHH
G".Hi0KOOF"JѓuTD*P%D"@HU"J$TD*P%D"@HU*uhD-%D"HZ"@K$hD-%D"HVSDXh]$B"@"6XT"JmEԧga:s+KGgI-݀Fv%Q]"ݐmJB#ݡTJNU'UZ]		tT
f`WqjGR]*Tg	+x)J Ku`Wq5v%PJ O}m%нtS(a@S 4HcN{uNruY~鎥Wr@u˨WrHuPWPvx5()UTՠl^
T
zmjEu5ՅjZ%qT@=8x5PO/T@=POPp5<ʟ;4JKT_.؊H<=&-֣m*1DΏce~26|x=^m4`/	vFD[el"MOғd~26h;_d[el"z;?EOD=7nM1?]ϰce~26|>ҳd~26FU=F[el"|nDf;>Q*ciPϷ-E*ci̟[BPl4";߮e~26(a%2iM0^jt̟dM1SmO^|26)v>32V^Gt?U*mi:N#vVsOߴyVd}zns<@źS{2Fm^.*$$fq$fF-$ڦGDDȦ$ڎl~DȺ$&FVEL:2D۸HelmcD}VzVVVVVVVzۭLVqnef[jۭLUv+SUTi[jۭLqUy[)*oۭLhx.vqdP#{˒{ʖ7\LeȊJsQ7]'v(ë*53m"ߩln=r 7=2hTdI.󶄛0z@^pQ*/K	C+Eq	7Eq	7P򢸄p8U(.&Q͔%܄	*yQ\M&/K	n4	oQfF]N}O}_gmTglR[1G<~?r5C tef.r5CGQ=D%zf(|@dDf(|@dDf(|@dDf(|@dH^s +OC3쏮4~J=eOO331fҨ|QHF @4*iT>Ҩ|b}9{(q\QY rux	9~"W;aMȕN.reH&Dh"+H&Dx4)hR>Ѥ|IG&M<x4)hR>Ѥ|IG>r,mo87
"Wӣ~"W}!
lD.i`3Mu+T"W4M%rES\T"W4M%r|YGf8p4+hV>Ѭ|YGf#W>ܾJRL%F;Au6Y^ryUr4tMv+dM&rE\d"W4M&rE\d"W4)И|@cy4)И|@cy4)И|@c$reD79-vd,/\AN&G\%Z"W}!
nDJB]jW#W.reN䊦Dh:+N䊦D`(hQ>Ѣ|EF-0Z`(h!8D⨂vҷ(#WGӕduURK[i=+Z"W}!
oDc@@
\jW#W"W@@
\+  rDX*hU>`Ѫ|UEV,ZX̏\'+LhǔLNHF0qf#Wɉ@("W"W}!dDPծG,.re rDP
"W@A
(\)hS>@Ѧ|ME6m(ڔP̏\++`j8Ԗ	LNIN-\qO&g\%	A
4\+p\ AUAh"W@B
H\\
}B"W"W@B
H\	+ !r$Dȕv$ڕH+hW> Ѯ|@`f~\Sģ􈸀frvrNaj<]M+J/t
+P!r*D@U_Gv B*(t
+!r4DиծG,4.re!r4D"W@C
h\)P>ѡ|CD7#WwK,:(.G8-%lx*@"WC
t\+!r:.rL'J
0@D
\+ "rDDEv>re!rmjt+ "rDD""W:8t*pT>Щ|`g~32˩	#%{:\%
@]D
\+P"rJD@(U_Gv@]D*%u+"rTDP*"W@"WBz=mJt+"rTDP*"W0t)`R>E3?ri\USWrdoaj	>=!\]rCˀ\\!+ $rDB"W@H
\\
}G,DB"W@H
~,edG6H,:"/=.`(U6x*n\"+P$rD@(E"WH
\"+Pt\{AUb(\%+$rDPJ"W@I
(\%+t]\Y(]j[(+$rDG`/PJէ$reNjK&%//\,'eW\%/@.M"WI
4\&+$rD@hM"WI
4\\E|j4\% )+ %rDR"W@J
H\)+ %rDEv>re!u+)+ zB\D"C"Wj@x^QzD]@5yMU	zr6ySU:tU"WJ
T\*+P%rD@U"WJ
T\\E|jT\%@W-+%rDZ"W@K
h\-+%rDкծG,TZ"W@K
h\-+%rEp5?ruDLSԀqȺkG#W%MꣳۋG`W.+%rD@]"WK
t\.+%rD@]v%J"b"W@L
\1+ &rDb"W@L
\1+ &r՜߮G,.re!&rDȕ8?ruDL{TIk
#W%Nl⑫x5(e"WL
\2+P&rD@(e"WL
\2+P&r.rjP&rS^
DPj"W@M
\5+&rDPj"W@]M@"WBPȕPjխ2R%#k`/$1C;Zs>&@2k@;:O^CN׀PN5M^1*-@U(@$z
hw[5@>
z
k5@^I\^Z5@>A^k|"`z
OOMe!{IBi*)ޟ/=. |8E6Ŝz=0"Z&kA= 2R[_CׂPZPNucT𵠞JkA+vkA=ͿGR)Tk~ZKV_UT]Zj}
Uk's@_GeZybJJ&K~>dou$RQ=&f	^
0c$XiM2T8U&f|	,󡮱DU&f	FOd?Veq]g|261z4[elbKu[elbX;?SϔlYӳl=[*c+}oԍ2261K@seVeD;?Oϓ,;@/V[elbB;ߦd~261[t_|261S=>S}m}>S}m}m}zLnSMt[Lp[B}M0Em}]m}^"XdPpKe[.([|W"zoE-]GqǔjmIeaY
ddw` w9K%rlEiKsܥܦ#^۴j.6
ҥܦC-KMR)KMS-ҥܦ1t)ij.6MR%t)}/]mnNSԾ.%MӬKw,4Ki5Q?Sf<1ț=馓?
ѓD/#AyMI&MHٯ[xqc
J*c1~11>2|QxٌWxmc/aqF%qF8>wG̷K8'd@=_7cژ3X׃/rJs+zX
-Zfе_`9VE`FԌ23qƊؐ㍯s'+xRON37I3*H6c7V;+O8Ds̪}-D	~+\enEǬ6c5fL4֌IfL6㘍
C{t%{9}]5Ls/0X3fq̘m37ь+Z{JŌu={>?h(7_`=B3XdF0cf,5{cŲǟ^-{9㏈cpg܌Xaf4c8Ì5fi[7VS^pUMsǙs8wsxҟésϹ<ܹtDȹl-̷I3n563n73>e34.3>mg̸ی{Ɗ/$
g~'9||~9=R}f_`=x،/_2f_1f|͌Gx̌ьol*8FWpN9}gs?st~rNVGQso3nj}3~`fЌ?6cf_?5i3~dy-n?+i9~2M7)ߤF1ʌfh3ƘQiX3ƙQex3ޑ2{G)w&oLMIT2z'̜}wrd}D#~961݌f#e;RfH#e;RfH`Fsh6D31ߌ3nLu(8RӢs\ysZ<~Kfy#eIftq=fbFƌefqfH} eRfH} eRfHec*&ʜ9vsIr7i<3>2@)>2@)>2@^3g%f\jef3r3o7Upg΍>i}|盺.uo8~Mт/|TQ7DT,oX"+FM2'곩
J@nT]9aDYAwp z3_՝roe|+5~~n"iyLД
FO+K}3fMݓW6grzP6`˜E2+RˬH}.t֢Uw$F}f|֌VoQȻ́w#u8e=G6~ߍs*wB#S	ԢTw#9I۩";̩=$;EWS_˘/b0}PzTQzL2,aGaGQsFq1þ|i{\|_ܚs'Nm5I!MJKQYfd_{R%']a#}ZgS?״r'8:=9ќjҴќ *{!%kpީT
T'SeCt?lNa2E|dS?w/s'<&YNx^F."c
;]8yԛ >e.w7>-OR.OJ,O='O*z~4:ߧ47Χ3cs/^Ӹ6sd/cҵ|dF_#S/	#9]SN^HnGۓjƯxԫ-ߗPi?1o͵5atZ0:Xy-Է
zrS?[@>*wݿ]r)QrQ!կٱ\*{w)IC]]u{	USt(.tY:UvUqiQrAU\ rAU\`U\u7мK+ҎƥwyDw7_*^=t<=X~O[4>Jnxzܢ0#>JbQf5cXtLNz٫
k~FNpt:i1Fܲ9}Ҝ>OiN0	8	3Ծ6Qw@w@ƦǦ}ZlE\ws(h1G	隂;w@}; wAUҸ4t\Pa઴5U\$wϩ; &w61j/=Sg:"_4kf_]ò~üsX&XͥF\`5:A.L5FnV_d96,R˹iùi.y6A.7kNbF.7oe.2_.&=[.KRMQKװCjkXT>:Tsnxޥҏ-g9K ϻkm~Tz[[䉧䉧ҭS@Q6y~c =~9연ii~œ]1	 cr'<&K	8&)O1\\\\ ?@EtČ"槤3}_PUzYґ{tNy"Vq@.t=@Fery/Qҫ Ş<@V=@ j.=@ ^4(zF)~ɲ>Ryi /&}NrF,=@Εa7Y{tE6 w_..LS.{Rsk%j6},@-K:CD!OdjY!TkdjYTK	ZˢXjFbK1;R\Td9U|Id;i-[(0;:6E[}Y6~rr29},d&Ju,df2Y,`dA&HGQ+2EF+"Y&'&Ҝgi.\V|dPJY+ө~`+Wɯ>+WˆSF6TwEzy~Wo]E`'7ث)^m5f\kuf\o
fG7imNɮ؂>?or뱹^{I6e7kry
:E?E7&3nmbۑ}^f?ks!Usy}lH\{^_#XEuyͮRo˽v߻Yz.J,X=K7^Yzn0]!TOȂճCgS'V"ƨnCDUtK,_By;I&sz~E?E}N?-R:3y?Ht~N?Ql/eI%O:\=mNgfNS^~;\Ytov;~Ss+vWYZm/ӭ>QˢYZm픗ov)^[dI龂tof;~;29+N_m/S[,N_m/ӭ~1Er3 Y$>o;S4-/{1hDXml#kg^Uy͆ȼװ"c41MsҘiibCSv`.r|U1Du9^l.7B&_)br|חcVS_=1PVGκ['\r|i.7j`5CUr\o6ㅲ]T3Tu9RXPj}9fE^?/(1ՅTV˺k\@kOrc.wMrFZÐx/7r|/m!2.2.r<]S؈e[\u9.d//&_0Qs9~\1;&s9 er\Wrs9^l.7B>jCr̊T_Qpqo(lmInͺW\s9~\5s9\o22:DP5r\Wrs9^l.7BF1+`rܮ/
0I kew2g")FpzTGbd;O!#a6r8"@=\G	nQrY'G8)NN"?
$UqpuMC$NEO14$A&iҀ4#8=-4 HN 
H3ӝ"HҌOi@1 
4sZ)4 DNH8"7B&#Ҵ!ͧ-y@y&Y1.+Je|G%/)k|'eeLYeLY#dLY	٭RH٭RY=KYM9er:L.~)kLFI^aVR[
qYiKY{2t^h٥-ebRSk2CfbR]!K1dv).Ő٥2CfbRK1=j>Kܻpզw)K]QK1jv)F.e t[٥:CgbR]K1tv).٥pɲK1<>+gNڥ
[]]T]ֻgt=ѳK1zv)F.٥du.e0إ]
إ]
إ]
إAR2vK1%P΁5:9k*t
v)?sRFz_RH.R#RK!RKY.(R]
Qإ]
Qإ]
Qإ]
G!K}Jv)@S
D9\Ԭ]6إʽKA.4RH.4R74 
ҰK!
ҰKY 
.HR.e0إ]
إ]
إ]
!K.4 K֙"OK0эE!N15Zg@H/5"Nm"PHur4NFlp:EjDN-F7"N3DFDi,mЈ#aE$RTg(مK&Dz"WW0M};&\y>m}7Û`M7D&s:MkBE&I3nr	Fs
;9"X"t	q:IkB	t݄81)1{	"x?Q|.r.Y-{P?sxaʅ}^xuxC.||Y}Y}BL}"L}KDշGT}KDշ.=.ȅϖ\~ xsA\<Ϗ8x.a?~&c`q2U/Cf ֥:./š'^F"f\Œ\q3.raE.̸ȅ0"f\sWpHe3)*UFߘgUUR/o!U}xUQZ7fUЬUGfU^1zUG7_Ʒ1tus֪>wYfUoVKͪ~U2U<`5CUfUU"HFUzUG02[GZv>U<hجͪ>߬ꗚU}!U}Y/3<>jZϓ0doV̪~Y/2Uvqx7b1~gݓ℄yVu=ZkYU}YUR+ejUŬ̪~YRժ~U|_`Vͪ	^Q/1{OZsFU<xҬͪجͪ>߬ꗚUAx"U}Yo1_fVy!Zϓ!Z7zUǐ׫z8y`q1gѬUP$\3?eWu-@?e_jU_nVfU_hVfUԬSV{ͪĬ귘U}Y/3\ЩXْފbxl==îr6	i&sdZc#FshqJh
C9b8G!1d#sĐq2C9b8G!oFsh+>֮r
1܉i1sd\k_;GQ1j#N\q:C9b8G爡1t#sq:C9b8GQ;1g+>nr
3Ii-sd^gH;G1z#Fsd7ppppps>98GC9\'O۳B;wrj)p)p)pQpQpQpQpQpQpE9Gos#GG(>r
7dAOhipipipA	p	p	p	p	p	pW79BOD%R>}=+9*s}ZnhZ;GHsT8GHsT8GHsT8GHsd
p
p
p
p
p
p_ѹ!էkv)>>#9*s}VndV;GHst8GHst8GHst8GHst8GD&D9BD#D9BD#D9BD#D9BD#D9BD#D9BDmp>[|+^Bg_r5\'m926_R!%R!%R!%R!%R_QqQqQqQqQqQqo79B/(WT7oe9GA[okiqiqiqiqiqڂ8Gs8Gs8Gs8Gs8Gs8Gsu.~ySh/~%2Tھ$Cgn/[:"p+RiGr܊ԣ8_nEќH=Ӆ"p+s-"DN"p+OT'"iXp
EjMERC%o?B+vSho*!}ӷE6"xҏ	
Gqކ9%!Ns8}Go	>'$N"x$95m@`sۀBֆ?E*GBėW\0pe|bw슉w8ŪsXf_WS\f_-Nq=_2{e5b׊Wf_'>^}Ne
b;7+Rf$H},eBYˆ3ßKо2
g~,k.x)xn/dL?tGqh|.pYeVeo7SW'CIq9dt'CIq9dt'CIq9d80>i3s[,@	Y>rh|ޛ2Ƨf{85fOz[֯jlz[!+zc|`y6>eG{wF,62>C<Ƨp}1>2\!eYjmZ[n֯j2>37j>j|^pEƽbp#||,^g?dy1>o52:DPRc|fE4Uu~}U__UgW!2>5u7h{?j|LÃ@l2>C<Ƨ~>c|e[P(\aϥym:z[Qy1>5u^Qx<ONn?e|C<Ƨ~!c|gϻy1>׊ 
χKy1>`k5Z
:c|0>/g(syY;8$&x~),ƗyO-Pqc|>dy1>o5fє1>6
c|.5m\$t_Ոho3mk3jA<8$Fi2>C<ƧmM|!c|gϻy1>_Qk1>6
c|.5m\$Nu"*j	hx!j|DtI(1[,X:4>6{1>7CwVc|-6#2>7s1>0\aϥĹnFTe|^-6#2>h!j|X{I*1ĿYg>릝DSb0^c|6&c|>gǍ1>3]-Wk1>6
c|.5m\$Nv"+j!6>Ci({XH,s0J;ZVg1>s1>ws1>3|.c|ުOPѕ1>_1fc|5|+s8ۭPtO⋨y6>Q:8Uw&d]/yO-xKmHkd1>2}jә$2>3|Oac|0Rc|fEt'FPP1r<'TS?F}oO;GfPv]rlA!i
pzNhC9=$aApmSvP(&pz[hI6@6@;Pn(¿	ۉ?
7?	;BopS?J;wApwJx7ܰO5@t8pK14Fr-@t(N	1CDhtc :dh|w*hCD$Nor0p<$4>t&>;JP2ݩd~	J;uOw> t^lŦ4:9N\Nzӝԛ44xJӝf0;N{ci;5
y>x><
s\4<
0ckqC#	06q'ΌDfNS|DjMjKcg4/qKcg4/qKcg4/qJ]MP[#6LӕN_n9Q 3t|~G_Wou2t|~:>?Cg*,>?>Q=33/,Vq'9}~3:d3z|~FWos9[4+$>??92KR-?Y>1;9|!owN>?R#>?R;Ϗ(Ϗ(zG`eQQQQI>#ũr6xIT,M 
ΙG|~G|~wA			jo5l@$|~DG$|~DG$|~DG$|~ҰHsfyD*s|#/&q>9GHϏTHϏTH+5">?#>?#>?;[



,_/>?RGs/J͜v˸vQn@HϏtHϏtHϏty"X"#">?"#">?"#">?"#">?"#">?"#">?"#g׉Ϗt?8|
^B9?v~ӸNN=͎NfGJ|~GJ|~GJ|~w.QQQQQQQϟkGʋKR7/|c&omq.>?#->?#->?#->?#->sڂϏϏϏϏϏϏOi//@+/Jk|8>չ^HϏHϏHϏHϏH ":>?#:>?#:>?#:>?#:>?#:>?#:>?E}#}%Wss[?X'79߹]o_}~ |~ |~ |~ |~ |~ oϏ􋊐# o|<>Yj|E^



,ځB7
>?P>?P>?P>?P>?P>?i_Z|~PXZ$~ܗ>	}?

/5>"_}~
|~
|~
|~
|~wD(v`|+$@$@$@$@$@O4VTOCMӂ?Nb wjK kt@:A%i	*#8]/tHN 29H't	*c8(tXNNi	49 tdN @cq:WiH'Ф8xBh|N!4߮S#\	*?*UGFR
[ZiǸ˸NK;k2iSdLWtV0]3"tFr\Q~ thNg
0]3L3LM`h. JrB"yL`/tN!D]"\:_GHRgKz0p`K+&ʝggFZ˝%W,wI,VXyARrg6F	ʝ%D(w^$vY,reL˝-ȕ;[ő+w%D牜gq<(1~-ӬO2~>4+ӬO2~>4+ӬO2~>4HV7պd&c*3qh{(+U.4SN"@[1#
2*#
2*#
2*#
2*#
2*#
2*#
2*
c~X=݊hZRe]c蒨{4+U.<Sɝ*Ae"HҐ*-4 2"*#2"*#2"*#2"*#2"*#2"*#2"*#@"*?*2,s%R>wEV\Lʝ*t\DF"Uvukѽ_jD4**#2*#2*#2*#2*#2*#2*#2*͈Tr?tɤpV\\	 L;U65:UNuLkB:ReWxGD&DT1*"*#"2"*#"2"*#"2"*#"2"*#"2"*#"2"*#"2ݍhH*|]Bp<>*[
SgsFfɸNWuTy،ʮn6O͈Rc:U;S;$hFTReD%UFTReD%UFTReD%UFTReD%UFTReD%UFTReD%UMWIOK*ܵYr%0U~)wlmqTɸNWuTyڂHKA[Yʏt|Lwt|8-LȤʈLȤʈLȤʈLȤʈLȤʈLL#*?,2>y
]blr7gʃ)
ܩ}٤ϛTI*2rڤtԤHMn[]OtHLt|wLw؊ʈNʈNʈNʈNʈNL7$*?$2R<[.tDvdʃ+ܩ}դ/Ty*?iRU&UNTyNTID6 PNTNTN
HTHTHTHTTTO*#^Ty0Uޟ;U6TU*lRMIWT9mRe:UReP UvځB[b:U^өS1*?ө1*өb2P*2P*2P*2PT9%T)wtLeʃ/SҩCrT̤TU*lRMIWT9mRe:U
Re UN
 :Dʯt%Su1*?ө#1*ө1*!k*	2*	2*	2*=J
#ꠤFJR:pSrh*J1&U~٤ϛTI*2rڤt*ʠB:L*өk1*oTy]LOtHLt|wLw%	4@C4@C4@CL7%*TTFaCGFuTRSR塕i锗;U6t&TtHAGTU*lRMIWT9mRe:URe!UN%. "U"*өk1*oTy]LOtHLt|wLwZD@DD@DD*U+TIAg I!aI)YPK	nY:5#wlNMթ2(*2(T*jRMI4**MLʠDJʩiP7P*2PTݘN_TyKLb:U~*SGb:U?Sc:UCBn"U*Re"U*Re-T*A4mHK"uTV<{D:ulTՓԩ2h*2h*J1&U~٤ϛTI*2rڤtZʠE:Z2Re #U2Re S1*өNtTLʏt|LwtBFd@Fd=t_*V:z舩L6~@#?^oIJtN7U'ZTFp-H)`6X/jc8^Pvot9Mzn2^+it)NO	`@s_Bq
+B3=Z	juCCGN:2g_ɾ><#GN	N}$ߠK5	p}T)N>)&(N
p}7\J	p}7Smp> LrJ
p}@hs&5=N> q[#8/Ao]^zM%CCGPuhRmHáVԡq'4nREPj_
TpƩ#Z4%T2ՙP%Q꒎AeDT%ҮL$veG'$1LJWp>o*S25SbWMT{0`YNuǂ3x><]sbtI<dϧgf<,sy0Ӻ;5tV*uԙץ>-ץo]
H9xWr]
w5 j@Հ9xWr]
w5 j@Հ!8uԁ
N3R*uޱqٹKFDԑ|LlR"Q@$JD(u DԁH:R"Q@$JD(u DԁH:RէhE)u DϗF"UJ})RG1JajL}EjD*JHE#U(u Dԁh:RQ@4JF(u Dԁh:RQ@4JF(uP:6J뫥LURJ};Q\ǵө.uRRQ@:J`MH)u "Dԁ:R"R@DJH)u "Dԁ:R"R@DJHTԱAJH[	U*u~ꂬRGI~alN](6#%ԁ:RG"Q)u *Dԁ:RR@TJJQ)u *Dԁ:RR@TJJQ)uP:^RR^C΋J#X~4Q|Guө+s:-Dԁ:RR@ZJy"h"S@dJL)u 2DԁȔ:R"S@dJL)u 2DԁȔ:R"Sz-uR^GyXURW*uҩs:"p+RS@jJHM)u 5ԑZ ":Dԁ:RS@tJN)u :Dԁ:RS@tJN)u :YR:)u Ƚ4VYux\/#wޖZ(!=ԁ:RS@zJHO#u:RPJ@@(u :RPJ@@(u :nEKK -A@URNݙUlөs:@;(PJ@(uP
:@RGj:RPP
J@A((u:RPP
J@A((u:vEKk
aIiPRd:	K.u :RР:@RhP
JA4(uРԑWJ@BH(u	 $:RPJ@BH(u	 $:RPU_RsRqoiQRd:	K.u@:S+Ա\JBT(u
P*:@RPJNQ%H'PJ@Ch(u
4:RPJ@Ch(u
4ԑg*+ *b?*u:]0tVuce\:0]Ct(uС::@RPJC#DqoL:0]@D(u D:RQ"J@D(u D:RձhREXi
ROg:	
Kr:@ݩ5q]Xץq]X.uPJ:@R(Q%JD(u3P7PRǃ1]7KKnT:RPQ*J@E(uT:RPQ*JTˢgJk3AJ*fS/d:
K[r:P=
q]Xץq]XץThQ-JE(uТZ:@RhQHmzL:Rǃ1]7KK d:RQ2J@F(u d:RP=:H6AL*h[S۲Jr:`q]ץ5q]Xץq]X.Pj:@RQ5JF(uT㙘.u<ӥcqoL:`@G(ut:RQ:J@G8Qꠚ-u<-P>v9GV4nR/F\:ucC\:ucu\:Vucz:@RQ=JG(uУz:Ro
p}@JcLL:Rǃ1]7KK> :RRBJ@H)uaH)uP]:&{cY¶/sf:Enya?p&(9mgNk8Jp&(X	9gN
3Aq,3Aq<	)Iv32p&Pڜgi8(=N@9ELLW+,
Rql<8ƝTѝ5du̹vk25ylj`MHG`y"X"BD:XH`!",Dt"BD:XH`!",Dt"BD:X4B"5NBxk`[sיel>"6#%,t6Q`!*,DtBT:XJQ`!*,DtBT:XJQ`!*,`!G2l+}`_sݴחemNA[BZ:XHKA["Bd:XL`!2,Dt"Bd:XL`!2,Dt")`%,=1ݥX5&Oy3:Xع7'w,"5,tREVDtBt:XN`!:,DtBt:XN`!:,DthRF;XoJO#w$WJ?YU\/}!w*!=,tBz:Xi"x:X@@`, t:X@@`, t:X4-7DJj\z}15
맽`ڽ3vP
t@(:X@`yg	@A(`,tP
:X@A(`,tP
:X@A(`Čv!,P8s*}FVkУ=:XG`,Уzt@=:XG`,ot<> tB:X@HEB:X@H`!, e
p}@:Xa4),[:A8ǻ/U
`cpB	t@d&(E:XH`",Pt@(E:XH`yip&PJ:X~ALtPJ:X@I(`%,tPq*LthF;X;+ctHF'V*a/;X~a4`&,ФeM:XI4`&,Фt@hM:XI4`&,otR:X@JH`), tq
!t`mh>\S;gp
!ͦzTݭ{K%>[B|+x(N
ƫ;yŤdCX-@V{ZmNkrBu^-	U&TkW#9mOF_#
b΄*U{_TN~QQWR&mjui+T{{CjM.$$={m
m	-xώضXnځBU,$trkBW,%tr{BW,w$trgBW,w%trwBW,C(XRT,"
權ߞb?,@tKРb	T,A%hP
U߂@BHX	K b	$T,DU,CHTrtn;DU,7@*[b5+b=+;b3+bBBŒ"vb9]xU?wdU,u<K
H1TX
KPb	*T,A%PU|GNS*@ChX
Kb	4T,FU,ߍ>vXn@:FU,$trkBW,%tr{BW,w$trgBW,ChXRԎT,KgiQm~oVrh\wZڟb?)tKСb	:T,A%P*CtTf>XK b	DT,%Q"*@*trtrHU,70]@*[b5+b=+;bBDŒ"wb9<+!:,"
Yˡ6tݲF
JT,A%(Q%*DXKPb	JbxXKb	TT,%PQ**@ETݘXn7PfTrKBW,&tr[BW,'t2%EHr]QL8)-R\Vr]<K
TyXKТb	ZT,A%hQ-*EXX#aQȨXK b	dT,%Q2*@FȨXX}2U,@XnIքXnKeYw{EHrp]|x}Be+YR4xi[y*^X/Q5*FԨXKPb	jT,A%Q5**HM:*@GXKb	tT,%Q:*@GTݘXo/ЩfTrKBW,&t2NU,3px\W,CԾ:ܾVZTaeii<K
\]XKУb	zT,A%Q=*GXKУb	zb}> b	T,%RB*@HX!K b	T,%eXNof8mIe!K䑊abA"
YR5|<K
L"p&(RE*HX"KPb	T,A%(RE*HXX#@I(X%Kb	T,%PRJ*@I(X%Kb	bB*;(8mgXPRhXeECGERK˲*k3Uy*~T,A%hRM*I4X&KФb	T,A%hRM*I4U2DsHX)K b	T,%RR*@JHX)K b	T,%ei}RU,@XEh=]ќ7D<^ZDU!ݿڟU,eحH7Xj@gYJTX*KPb	T,A%RU*JTX*KPb	T,A%e*KtRZ*@KhX-Kb	T,%RZ*@KhX-K-B*!bO:VU,ChXRTV,ezMiUufaVŲ`<K
lv6R]*KtX.KХb	T,A%R]*KtX.KХb	T,AWU,CtX`g1K b	T,%Sb*@LX1K b	T,%q@LU2XU,I'x6SX[JJ*w_+@=
a2.Կ<_"8P"x(Ux(x(1x(x(4M9&C'<Gv9}M9©S8sNe>xPOB]):
8{eAyI	qMi#?\cd8O.g负vo3@v-\i=Gr=Gq=Gs=p=r:Z9%蹠=0z.hO\_	ssz.8}O>/s|*>z.qjtNU\ /d	sSQ!ʹᏎOо
)1K*qU D(EMax7bH%^ \k	UÛX_)5C	NBo*
5#	P}ф>X?P/	.*eq)OHפR&5SR-&ՂiIk5{Jy@0Ε?ϟy8xV#y4xVck'[<B|x1b-[#o!F>B|x16h(i\#ڳ\-
KYbazGƵ׍gB9H:U5JeQi\#*kDq45ҸFT׈JQi\#*kDq45ҸFT׈JQi\#*k>m\WH)7K/ߕո.@6ݸ6q)oU:Y5Ji\#2kDq45"ӸFd׈Li\#2kDq45"ӸFd׈Li\hz4vwDWJ/|>-OVz0q܍k#p7׻q)[nEtոEWPtո^+VDq45ӸFt׈Ni\#:kDq45ӸFt׈Ni\#:k>7m\Kfv%Oߟո\SF6@\7uzw\77uYm@ׯt:@5CTzTۀ5и@@h\k q
45и@@h\k q*#qr^P2r!Y]?=e\Ƶ}ʨn\޸n\n\?+K[CvPcqJL7C(T:B5J(h\kq
45Pи
@A(h\kq
45Pи|TU{2̹P

HC1lD(.b{APAW\ˮ"kFQ@T7s狙ϒ7I;yxMt㺀8G/TTJ׿o:e"U
@a5ݸ!i77JqN_Tej\vA؍n\ Hz]Hи$h\4	׀k@5 Aq
Hи$h\4	׀kxMmuhx<"2*[Ҹ#|ìS{" TN2q
Tu;ݸ"Fi7y)hи4Vz
n\ovո.@c5J @5AРq
hи4h\4
׀k@5AРq
hиѴq]@%E<2QKoU"0U
`5AXFi7wHqEڍn\ӯV50׀k@d5q Va7YDVzDh\"4׀k@5 Bq
иDh\"4:6ҍkWӱM_Ҹ}N7
U@	k5PB(YFi7wHqEڍn\/,U5@C׀
k@5{ݸnvzןqm6
k@5BPq
иTh\*4׀
k@5BGƵ@WԽ呲u:qF:՗o\zj-4@k5в׍n\vzݸ^R1\@
dh\24׀k@f5q Va7?v]a7
p@5 Cq
иdh\24׀k@Vxn/iZ5Y~4[oSCu(
H5PCq
иjh\5q(i7HqQڍuGa#
H@5CСq
иth\:qG؍a7
q
q^WG:4׀k@5CСq
ʱ*@5n\~#nZ9QCհuhq]nиzh\=4@k5г׍n\vzݸ^:Jh\B4!׀k@5 DZ=n\7qU؍Oݸ~W؍?
q
Ѹh\B4a9V/jFBq]J6q
F<_ƨ%*ԩuJ5NX	Ѹh\E4"@k5PD(ZFi7wHqEڍn\?T5k@5DPq
(Ѹh\J4ո#u[ݸ.@i5PZ_	(Ѹh\rVJ4ոn⎌n\q-埨*uRI}:o\5c&@k5Dhq
4Ѹh\M4ոnvz[ݸ(:F&k R4)׀k@5 Eq
HѸh\RqG؍a7
q]j\ 0cr Eq
HѸҤq0thV<'
x
xUXjNMP:Z-gk{Ν=kq7:ש{_g}"v
|5ЗX]NW}7VjjꩁA:hુ~6jWڨmڢq
'p;4Vs5jAjjCV4XuWcƪL_!htCj~XpWӹ	e@.@V˯Q})lNůk٩&_B
e6j2l*R%pT\QtY
We..^xze+#.M\VriZʥQ-Pnaz\W*JVVPZBN?*ԓQr=8P?o%mY<{8{$[ߞVo)lM0/=ocԚfƍ%l,nXO~驞qS=Nq{`;Nq{`;Nq{`;Nq{`;Nq{`;0T諅
lb$?G-<^U(6~cuj-/l7zMohol-
dddddddddddddddddddddЪ
Gja[[g-J]"lԩxaGw
>aaaaaaaaaaaaaaaaaaaaaUSa64u~>T)FqCCCP6
@a@6
@a@6
@a@6
@a@6
@a@6e56zka[q:XzB}Y"l^_ l|ER4G@P l
@aP@6
@aP@6
@aP@6
@aP@6
@aP@6
h[M#618ln$,}K}+6~S6vF^&
@ah@6
]1X
@@a@$6	
@a@$6	
@a@$6	
@a@$6	
@a@$6u56Ш౽uzOau9syJ_y6/ld!lm@І!lm@І!lmK%ma^&
$
ahC66
sz !lr !lr -ac66[ؠ!lr !lr6
Z]SaB@{j nu9a5|$Sy!/l2ՀWu@P!lu@P!lu@P]6-llҀWu@P!li=
@aC6=
@aC6=
@a[naۅ-llA^!lz!lz
kaۂ:[9üDh?\g慍"jaC6>
aC6>
aC6%l쒶Q/macC6>
aÜ@@@@@@@@@@c[va-llWc l` l` l` l` l@k*ltп:#`ye<]FMJF:f9Pc^ :W@
FUzj0
^PQcBB_.=5(V``B($PHauIzj0YP(Pzj0mP썯jE{6Ptj~XV(kui2
]1
u(\
pE댄2.kq jyz j1@b4XjZ~z j1~遨h聨hr끨hDQhz j1q^QHQ!Ic5SD-$T=Vc@bHL끨ŐcZI;z j1$`Q!v=}ڠC	tƪ0$cz-MFFcu7ƼV3"Ơ[7[S ;om1a.DJ~!cIE8'3GӁ6SwK~z2h&aiLv)gLɞa7C&d?fc4udL6*l2]BY~eebvElVc1DWt:6M:vV&og2[̲:$.:%(fGl^̆yb1;QggȳY:)gY:'+fnyo1Wg+Q(_.f/n1{Wg_4sL1Yw&c1ɘteEL̖=&k(͜mF0ٙL6V0:&YL&:++*fU:uM1FgZw5|{:LciN
;˯lo]&dC[)~&ɮbl!r:L&/}d?fQyOӣ;=d1Y&dcɦ2_lϜa]he^o}m,dz2QL63Yu{WVv%sN&[d+)&{bs&VWV*-ufd1	Lv2d3l6뻯ܧ3f|l1[d0V&k`=deLf2Y??++w"2YL&]d73=L =d1Loo(>V
:c(Q٣bL֝z1&dd`2dә9/	-}Y~eedo0ٻLɶ0&k,͂1/1/1/^>Y~eesb2&d2"&c^2{d2e Af/C^JPP_;澣D&;ɦ1EL6ɘssb1Cq0Cq0Cq0C̵Au@X_0sfu@3ᓘl*d3
&`&{^f23ag81%}&;2H&d5L\Gks̋0l!-eGY&{t""[TzߨLfvLօz0ّL6*y]*:a2eQeQeQ4ʼjg1Q3ƜwƘ[9113ƜwƘssc;cyg91睱YL60]LV23L^EDz򷛑Y_=skm~56~kqQeXq8K%[Ú}|8gq8gLy]y;s3Y=*duLƼno~[:`΁ߗfTȘcn9&cnIkK˯-q4scx&df2Y.|6zb=dkuL63v&{H=$J2GI(ɜ%$s~dΏQ9?J|_}_̱3;̱3\W&$s]d+ueL2ו]k*5żb^GM1QS)u:jy5żf3츖b^N1}׾So1w3&cy)昗Ld$3Y?&|LP9J3Ci|(͜4s>f·P9J3C駙l
yn81?4L`l?&;Ɏ`2h0D9&1`sL4m33kH4WU&k~Y>d/[&c?3g0ן3\fL33闏g0ה2\Sf1s\0s\0s\0s\0s\0zk]g;12Y3\cf,eSsjyN2ϩY959Wr&3䘞L2:zy=Ǽc^G1s9u:zy=Ǽk~ߋ9129\F129Q̹beT'&;ɚ?AL,Y1?KVϒYL,Y1?KVϒd~??)Gbs}o2&s}o2&sh2׌&sh2׌&shd2dMd^S7M5usYthQ#K|P,ψ7Ňb|ԃP%MKh>C+%ZG_+
IC	9SΓwER;ccccc{ggsL<
:Nukkzק]?ɝr>=]>}RUݫ/?x933SsggEϛx>zm9oo(pxobwz{Wx}s6_u;wɾ}3|}V^[ķok7?u{@Y@:zF&NL\x0*B-Ơ7&vV{
^5(,*B-Ɛ7TʅFN(4'4?t[Ћ7CC
5v>lۇ>)<5|^xf;	?~9VpcGȾ"GFFF&Dj"gD.\*rcdadiȳW#"?Ep4m=2:8Z=':#zYt^ц螘/VS^ɱccbscbwŖVƞ)lqeϕVvge~xY\;ƻ?/~Q_o	'	3!qDıJs⯉{%HcRǥNH:;uajvԊSWRoO}ږ1-t2]7= ="=>=9}zzzzVznzA5N`0^~ƁƱƟ3?RQUmC[㧌3Τ32]2=232S2dfd.ܚYYYy!F~ell4fydWv@vDv|vr]%ٕ٧kkeιr;5wHonHnt)irsrs-={?Yn[G%UP%UR 5JMT,7uY-T/0f4}́HsYca^`^j^e`|2D-(B0wx	 D !׊ă^y@=_w8C>={0y;y;ۖIoAoDxx%߼{Lޏwy_Nϓq}yKޛx|}ȗ!&ow;Ow|c}77|}G0_O ^%Ӿgȷ(ߝw%S4C0~'v%/CMK#D1F#}߅/_&I?Ow:/$](6Ў@@;?k6fP9890'&Q@%	@88ЃEn
l|CSx+PXXIyCSS3˃m)(((
I
>M\\B;wQ
^KK(x~p:O
Nq
B!7,9~@k)Jp
޴nUBCP
Ѐ@
IC_P<ԖB>ZzBOУZZJB)_(|f,
)\K)|lx>0|w^r
#q
DgQ~  C7S5koD}EDNȤȉKC(%ҕ""{S$1(D(*"Έ?wRYYNE(rk6̧̋e9"Dc)ZLqAѣ(3ڋH\TQMި++)Cll7)8wF
2:DgQt=Dɱ);!6b*)vLl0ĎBvK{"b;?Q4E_Ce7bnصybfP9T-LOnjڛD?
Jr-v-!;uzNJQUO/]cruMW\kHT}8 wGVn1wrng==ܗ{"rF)S=}GGX$KroMW 3gɽ½܋Z\CE=sgy"9syt"^ry$nwg9M|FS_(rJNm;u$	JPJDҕ>&=ҽ}(%'ϧ_U~(Q6=ҳӗQʩJ
66$m*۔9ߥ)EKJ;ӌs88*2Fcb?@_FB9SwdaIƋd2VXN">2n1n%cqe*2)!ӑ2LLe2v
dl1J^MΫWSfqf	eE2(sef.e.̢9-s:e3)36322)cf'eeg)~ʼYKW2k(TiʬȬ$y˜){aveΞCٓS({BveVR`Iك=(9ۅٶ}=eeϾ@'(Pve.-[){mvegg/#]N4."L.'Z۔@H^)=w:ʙ+))''($;
(1-܂܍rrRnzʝ;rs5$QxISI#MOj՞TFeIEU[y(+r۔Lǹ
w={
Nb5Թ%Ǚ(N'"p&\)3ſG/_R+h; LSbZ\J8'&(1:1CC)7я=̟
/Cb+ţ$Ox!֊;b'$>	Dȟ7=0Qby2IE:Snԋ-L4	G㉎k!QV$z>BCHÅ/&(Nb8Tq$".21J!I,nt2M!:
MD{kq!2B2*c±ر;r/YNl'/8^$ZBV$
Gc}e?Q±9΀q$+hL:S׹e~$k <9Hsy$ϗӅ8g%9OvNr?)̑4y7ʛH,oȹH~,7:#NyMȥ	rjuI|>9s¹H+%Vow.9DS!A7DЭvDȑpϋi	Rz@8:ڑc?G'AIzJ8v GoGADoЛ11т>>q9:N}MW߄}zPKtoPKnLargonaut/JBool.classWKS>%- 0,G0,@X`Ӓ lxj~w٤\JlW&dLs[
qUu߾wsQß6"P
]-a@]	,>jA%ЕEme*u,I|J*KDY܍a$(09LbDanER՘$#߼jgwH,Nf?iN"1[ѦRCSo,l-{gyl'Q*h?2.~vĐKLcħQYjVCXڴs͊\[G5Q0[ʉ,i>Rsq:]ćjqY~|#7^|czmpZ&Vq݌=moH
	;x:bqga5[i	DG6օ=SdYc
9qz'<%^!7k"L4۵&K_wnf#!qwM0)xXIDpq>HNJoUɝ{YU-'
~;l~ٹ~dO!rIPtJ0Nܳ9hyule^N&t+
":df+-ո:œ&㈹RpV(
IENܕ7p2bY6!($¸Ce=xO^mrjK'ew$xNmlJK+yO+|Xor38B};DOfvKiAqƹ㸃OJ]s.νfLpDp&z'2A]j*rBٿ4fc&`R0Er;ӥ3z8jVq8atR7}HM_iP1d:'< 2
;["$`F}J*"|w$KdmVTMuN(?"|dv\kiĂ_AHX%*@0ٱ[FplhғUIY-TbBOV}AiUϖK,?LP!#/ j!RCS*{x@4
mxL?oUC8@uM@x paLc 
y`բz!CxtT5M^"5[#+*X:Py5S
8׵QF++uzl#S\5Ŭ6J=lKyAБeUI(5u2f÷QDN;+>yqv,8k}8x1p'8
~\Vj-,Xk{C\)`)uRS%T)#U,Y"A?et7.bxCo/T6l2I$x!5 
Rnö2}[TÏM[᪝2556%8q/k;'(>7w0钬F 
*}CXt9{Q%X^V:ުfU#J<]QT_$#y ۽7TdpH?>@n]RUsc#H8Ըƃ@#Я0\fXG6Gq9t587%
s\BONH d8'E x=8OOUk){L|Y;~pϟ=N-Uά#'tzچU"iEd$YªFLה,d?PK)PKnLargonaut/CJson$.classTkOQ=w۲lY!BKRy(T0Vkx[ֲ6-Q_0sk)["MݹsϜ930*f4e0\Z%jJj[`׌Fb)Ӹ&n%3Q,<_Ғ3^ƠkVմfcykgmfmǓ~2/J)_$ch[r^UtB
BBfֶtf!Q׽p*yxR0Hj.{eܠ[AsJ7Hě&*S
R,CGݻmt3IPpOHY&'HH@ "]a $N@+.XxjUBm(#N,֪fP
AZ50qUVtZ/їH¢OHkA<&Lb4~4zo&v,}sxY53k‡-^qC^4]9qM缟T	f͚UuAVDo4چޤYt毿Ꚇ:eӰAOk=7OjiFpqj~Q{*Jݝ,G9j]CVB۷6@<$2	vR*DɎK2]{qcc&r.#e>W4/rF.2	N=_"Z7/s-E\IV$<'߶SG{j"0>->kb|l{(GV"&8@Qg{
^>Ia(J\6ZR'NI1Yù+T
oP沇(`FnR+&-+
ѓy[b5y6ùxJϔΏ='^FP-K7%p?Rn60RTm)>@@}짃`B~`F=|:">ENʽ#E
EEx",!xFbL"߹|ĭoؖntK>
e@)9Tm=훲}HնCXd+ޡX)#JQI6I5.5806Qb=19p7)+:ቄҼy͕h3jfINZҜ-+<=
'k!SZ2N!Sgt]Q_ǜGᐢ]=u;=Y>FiE2;M_ݩtr3ˡu6s=.LӖuF,OtFYzeB+[|30Yu񇻂c==5)kxighnÎm#szco)AOdG=cܫD;8vpTf8Ŋ{:[̺b{梎波EԚ竡E[{'Ʈ4p:ӳh=uc>EpKh~Rf7gOrma6n,%
Zf-},VK>[CȖ
xr߿̳ƽ{\=5م63]fi@1!ʖ{BY̞ۻ3HnRmaր]5Vxot3ma+Dh%_3%X =%eyB-{c{+Z
hcn_'69;kQV۳ji]TA{`|ou6dY(]rc2ji\_>UԾ O~W	Mxl}~gR33ys|sOIl3gNoYyҘz	L˸vB)Jy=J^kF'3<,\,Փ7]xu|IhW_ArǒhlQx=͡P
<ǢV7JN
s*JF{&=yb0d!tUV|HjBV̆ܠn.77z&e"???	ݜ{#l,	~뎦]
PSSWwp#Pywk-߄붠|MHhȆloO#qP~s 4xgiE?SJKKS	6jH>a{nS
@RxY]¢``tWzá=g7uF&kZBVxv`+N=LO$:-e  Yza^d9ףj֒O:~:ҧax;^s$cTk^J_SԻa,t@lONȚ1hH\O{^>KfCuSBW`52D~ڂ~kq͛TnhGdh+V5243pֵ
<,W<{4/p4R8XusE@d놡E-]ّ0l94·\	}/w\pliσpn6
<`S%~2OۚCŇfa>sE:1{eli~ȳgJ7]JG]ƹqo~feafj/m(w-]О|wUnut]Ʀ>W[p&,Zþq?{e'!`T}D|^d+>^q_-󂽓Bazv3]rAn}a_Ӷv6WCLYB2SٙAM
+Vfm|jwE97jrVm8%HL=ӓ?/E%k3W[=lsδ6s5A]-]هZ{|me"y0OxJKmLڻPL ga"Tl0Ev_=Ȇ1<&=4l)G&-i}ǶtT""ox欬зΌ-b"vo,\쁸^+)	
1uiE(#\,ܜWro	_!Wi`
A͑eZqCɳ76B׀]h%Px/wh@=,qk4w,[0MN+4w֞ѭ}͑'W
7!zۋ+ZL:V6UM?VgyxƗ'q	JY>e;='1ًdL/X5ˮR7L
kx^gKp_՞Pg|e.%;ʴ5]Җ*FW^(ͣc,||'!/7aj-X{a'𬧼"XM@W"_i8@{2Xs)d!N`#F6WXe_<ȹٴʕ|:ME@q_(ckiI?*zq%oNui
:Vx>'phKǚlϷE4vӢ1ЩH;G*b.EݕGl^uIx<4m D!|N[%BvsL\pu@$;άVwžqGiHnr
{KޮC-+	ZFU}wl>&MG1qh6!96z4Z:R<{\k''R+yH"H75:rNf	bi@TM'Svr|ZKV푩&&FAɧ;N;v9ɧgS`E 
]%j#Ɠ4ZMLu"6@Z^07#cz$2q`皸2Z`P~-/
X̹PCeoC722٤.0xV#'"H!	A~ܦ/gv+klpR5SiL~-2{(+H&824WF
.9J`E8G'ƢMjPTlG';sMFFFGG
QhzwDN6'4zM	!V|Pu*Bn!щ#"cSCbj zt7:RF9t5)G>/0%I¹]	P;u 0]n{2\-y1,"V`eKV%RIQB/%ndu-pnK u7뱴x_#xʒ€Wɫdq]ퟧc7
xNb^#Nu;/
^b3īuu/˽D1$sf#l
V;&iV %$LˡYzY쐦
ۼęhJL3vI3^Ȭm5NGzy74CZ9jznz4P(mH:dGăd\"5rQq/$&SUSRS՚ӈ{ptiQ=4X*)) K2q||	^K^kҴV~z/BiFi7[$'xqނH/ɑ6ŭ'LP07`ޅw{./Y\pdLIbMR
e>2
,qFaQ|/Eñ"Qe+IhC{#*X+nm.X#G!A5Y"~/蹂,UL-17=+=qB^4}KÃ#ӓ ($,b"VzIFXAnf֧OOk}\3"cO>~ɛs^⣟w'ium)?/YBa :ubdx&'4F,1	ƅv\6QfVu5I拎B,J֧>=Mᦿ\M'?PR2	Z]tYd7/(_AIǽ0,_o/Y.eW[F&U{0D'UcZ
FBR"
O;
̺RaN٘9)qR0Kd<<0F
N;L`45TNNªeXM4zD1yb4tukEs?2/YƖIRHiSѢ:.#S;s'+dEO1͊j!},gpö-t"FUv8G>NܩXٱxMe]a@Kj!0m^II88$$/:0[GupR|8G3
IFa`%!V'GG܏@"}he(TOh,":":aldQ⎍C^$,&lZ՝:Jj?mFةIm9c:YNJ|9,jۨA?7;%U'vbi/RHnjFø' @B`0GIL4eXdcl'פAX^,ĎY3I
$!3v@rX
ٜs49G$
"a1V-f넓ɼDb*RC8i*@NW(~&t@TY(KQ	(wxIiEMz&jjQRɻE[^pÑIAwK
?F:WRp |~R}$0%sGr񝰮fr_jAꔥM7GQ@B+7{K*PkPd=2dgE͞2
N͂Iq"Cm/ɓ2r&ىmc>]J}fNersg%^wY*:_蛪}A"TaW_d_--%W%;~$OW8ߖ8[zIq<&B!LHc?(?{Iu4XY8?8_zI
F"`CvG=`jӨAbZ؟`-D@uCѾCdw('t{trz'>
K/ VJpcHs^M8I''Na0MmLD't8[-yp%n
wC@c>
i
E":KłeZ"g,;gxƭCa7:vP?>X3UN+U5NLV-W:y*W9y*WvYUwrYUjp򕲪J_Y9EzʫV%Ձ=e]CR$(뚒"keݺ:0.T6iu(e]KR
u(m2KJ{Դv4'4ㅵG@~TˏQ+?jQ/?G(uNI:R'Q$JXgO+Gʲ~EcщvP(&J;|ΏrAN:_A	}xʧaN9N')F1r䬝Wfvl$V7NVj~
k-un~b^FOİM*_$R"3Zx(Ȇ~0mx:j7TzlOUp;W7++++qq\
(!n?9~BkuZъ
x)\5ʢny6ev85mGb')vx參oxInrX?vm5brk}HsbÍ$%r'vI|,T>#.tϥ_'-% ǣ'ae}m*l_QBl0

V6߂Uuwm]p(.z);@ZI&e,3?5?A*2;0W]ft.dq$ZK	=	V~^
|\G8a_΃|G]H+؉U
N6.XL>=+i2eNf`c&^y;V۝.t//[(NKŞ:TW
u[ը=$Ɍ/-K)Iϲ`
@߷2ig7[LK`
pLY^`Z
,r5E(k#5	͂n$b.]@u\z'7Y7(q~ak2mw]ЖzF[}smf" |~PKB"}G#c.['h@؃YX9"TM;%m*kQ
OJ?%e+Ȍzfj $KV84t0QG	`rdB^muԥǺSɢ,h&8uh2`;,d{&UzЅؘ'{xqW
|)yvܘ;'ھ&F)h>jkڅdĸC=b>C1e-crOjtM>yޚ`e͎P"Fl ˥dZ[]}эsD'"x.3]`TkvJ#Cdl&J 1	#&g!6BDnZ2§1l>ZH1Mi@Fydq
I>b,¡!
6*!ŲR+uhb.ؔFBekT5+*0Pϡ8֨Z4Q<jQ.ktVuYK"q܀n.qidO /
}ΐMZ
]8rT͐&iO)	ZO&g{{7lɽAŧ̐wWdϒC>ϭիdTA3C.>ϫ,ק]! sHn}KG0v ?S4GrEi^$λԮKh.UkG>ROR\
lG؏>|p\PKIDO.EܽH?|>Ԯ*bV`LHLhZ]
yv]
R\!ZRK
芁5	QOV!¼ҏΡãRG@3t%B:\:	t>uu:HfP8?C.Np3vp+ps:uxb.H.H.t8>8q/;A;@;AwCSU.S'GY9fEqGT5_::S!["ˏg	x'x_6IڶA.GWx0Q?ϘQuX*RV>øڢA[	3*e*4431
Mp3+|(x9*s7b|y&+/2pa#hƷEr-1`bc
(hM+qie夈Dx&KY5R0450;PIP)/_F̯@fFpqtqSscz[5*n6duX~Cdr\ Ry@6j q+EV7ZW_
۷оݰ֔m3l=?]F)5v|:89>aqjdtCObKnǀVKa Ƞ5`]2xP2hNdOf@_
Ee>Aڇ@cpv}/t@vrada,@%g@p/DUr7vK,g_ͱfoJmMWl
-)nU*jKpކca}TMt\zߕMy@{fDuBN>C߃zoa[<aU41αu36M6-D5dqNoX4^g4\.3*RDY%8^|z$xU
~Oe&זfӨgY%QylIc/c/_21Wy2%01O/Zc76'叕?FV!w0>ɚCA,xH
²QQg(ȂQW(X..ͮ+pO"cѱX$fMѷlz3YAo!
VJFҷ&J.Ľ?Z[!au+%3u=C~x02	fK5k[̬/Y9Xg34_6~-jDנAz[+*$!4'S'	cl>g9|N˗K}%Y5B6,|:wx'd~dvx=ûyCu,oVFv[xSHwÛ|/9ȕd7'"7=GiExK'#a~c_oϹ~ԫ@Rs18ޠ%`7CF*g8AL$OcwN"?&	HVYTXMB>eY7_n_4QNv0E
Zrp@|36\b}d9Wțs"5	bSwHK\@LQ}q#d?YqǘƧ}>eVc3bܯ
~3RDrNntGc\\JQw`%`ސGnGb-m{֝.3j|߫Wi o5_F{t>?'m?h(?]Np^,?;qDO<_x:>=${=z@9wꉯA]O|=t5E?	uhQc&Y-(ɤ̷Ptl\PduP9g*T
Pg6th3%ͅI	D*Z5X*egM	X2N*ZVvS)+Zvδc	"i$Q7/o
oPF)PkdYMղ,ee4O+S
hVV(ҕ|kiFW55Z,dw-|;
2@zղC|''4j5mo0h{߷whePieejeϪe__ʾV}%%Z?Զѷ%cyliޠVBRL~_qzY֦O-;dž)6MeWkkV}[ӀtԲOlFm)=gPA7ʒ~bP+}+M?3=?)4AIc%&aqPܴ<]Q{'S⁷$&dEx-H\ww@N=qLsq_\wMqqPK-"U4PKnL argonaut/CursorOpDownField.classWS?W,&y966a#Gb
ʶ0Ndl9tLg?6tgn#Y@0ˌu=s~q_
FW4UDR*퍺TTJy%DQuh
՜\	I46Uk%FɞJbv¬$Nh%tZ8sZ~dxW7D͒BsIQV|g#dLMdod;.9Z?|S399,#e_.FYvfM
ѡ(S-NFB
/)Qft{lx	~7th])I\G"Eri!89M4'JNBQ/	b.0qT!_vxpfPZgk(Rt˳nWn\m\a`Ȥެ0+#]ީJ{ r$gm(1qٙrrǷ
/<S|5 ӗo	lLД]ї`TjX\["tWX8H Sq8j
<hq|xC=Dpv/i[rnċ|T5nhl-ޣM

iq-'#M4͈Po4[pd8ipv}7xepOWEo޴LefeD([Ra7GP3j-O&)pSnGt35C'1	ab>8jozN̤v'^\[1No&uh GNЏ 8N#c@|Kwr?6ytF2}gGRm?{Rx{2؉EQaA;f8TB+yC9Æ~=1V|g "$â15"E^ʯPIVMRT^ؚ*˥s#wXSe}`m,lxh7xxpY6?۽܃
%=HAV[NJJ 0byTSsKV0XzπNZUN}W:F7	
	b6(}y$w@#Va䀱5A\E`xKLuMZ.'IK7/rg=L`j'敳qjjxSaaLrzD	ŵ3[,jg[ZRՕR!uݪ@[#)%еzx<f5L]%n礮Td]Cji%6F7B|uo̫}([$Oq
kX@yY?id0~QN6B
PGČL|EaU͕oyҧh‘O0va)0fF$5U_8}	0(.tSh,l?4 Cu8=/ރG3'XU.#5"žE1CU	LcMH߰)Zzf`Ōhԩ2To7Ojep73bܬghGюoakl}{z4#{c*j3r#]/Oh}=^#kHk{6b!:h(#rl,P8'}~`Ζ,|FT}'w'Xk\~Y78:GOp;/y;o?685T%[lTq1cX6K)ëJDN(MeWX6(c|8`$'+~+<=eڰqU\t&tʊ>C^tȰ?3'}v{cu<*!ő7C^#اi7PQRL\k0imjEE|/:M֎Al='9 <	G&y-w%j_t[vBV
ݨZ=
-QAll>6
g
J/Bo}=9m*%ְMJSU{cQPK*}fPKnLargonaut/DecodeResult.classZ	`U~oF=/ű#ˎ3Q;ݑ88vl'Nc[Ȓmd7B@҅Iw)--P
(G--R(t4eN-M"iw(sn|BZIĵTljbb)2InR" iW__X,/ZL8Xz6bGX,Lcfg>Z]߄Pg0ۊ,,v6R[p=InFi}cr]K[.NNɚRhdsIev£
6'Mh氂'!$Lw(yx%ȕ%% S#*\ϣ!9/T4=XɻIAɺDG]4
i6X3W kZ4eA4<;yX?@څdDߌT\>Ev.OrvEFV;:jV+a'p{$E9 E@ȉxmFdQ8P".I}כTe\8-
:շ=јz!pvo9[!ٹގmUmZ0hM5}kG<EQNC|c(j|DY!r{.ahZG	'M;eU%2f
uyKڬЕ}+f:JVNi2{ߢ⛰ao3+j|oqm3KBjۜ"^{Y	wǕN"Tn%]?yʃ}#SC\Wj%(+ݼypPJ8NTGfi1K5k.{_q"Ȫb푥pdG=\/J|Jl#N۸ aNFDl}$'~4P!L,b5+u$rC049C ۖJC
SY|hm$8/bjǻO(\FX5P8YRʡBUVU3_=>Xl(Kו+ji3x5qHfJpo饾drFe	$0:'n
Ӣ<\PT'ƛe?´-ĵ!٣!7PqnZɅU]r3m^DktyCUD̛8n祹h{jQ傞	?^y5ʝdn|}z+qqO%{(n)o²`ԨUA8X/xB:
0]WUcs[WKC]39bd)m!;rGx
AvhP9G<̔ϱY#:PT6myI:h
o^^Y*:nMANGJy֓a==l_dtEo+M1;E~.+[aߥ
R/"GUT!T#y.FѰ23-p>CQs$e+l:*
Q6MA'E!j,;œP/x!Ynt	PMx(N0k6&,s*%mpYXJ+-!V_hI>jd
)x3? UUQiS[ЂKUGTW8uq6~ԥiWFiAh؝ע+Hj5tJ/"Io8!B	
aoޏP3E"^/OzD\`"B
HoNEcjd,hde4A%[|ZҜEkKG\<?'WXs k>ڊWÙGt*IBDՠʂlOkݾcwCzeD_P+`y=K26"餃$߀gBͯ3G:C	_(=fx?ˎgfl̉n*>7f2@>PT0p
/3KVߡRuoe>/y~mGӛ~?{d3Vgb="Ÿ@VYlLK-%I'-g~0em/Mƿv*P7RAU&X(wCvB,|(Td@9RLE	xsE¿
t1v|lڱqqwUZp;[bdLMo+|
KFr$Nh[cF>_|CY`LˣD$J(|4+U`&TK؇LԶ(lVV4u]Äc,"x%p2wq߽3_\N/Hv<]t"}YH\JSVt+r5XUVj+LB.`+ *5NETj3&Xv&jbQ!>;ؙ% S4/ɕ sh?؈Da7XHeUKԂ.^;X۱
pu&fN;6+	8<1a9}[I(1`ã:{Q-`!VlbPNJydGD<(y<`R8Φ+cچk΍H~(Z]Vj~C@1~'5N[Ow'jJֳ(s}8lbZ2{0MFɥj|
?ZYuYu3,ُP5A~9sCʑgJ7A~;mmзwfzw܆_ͅA46ۯwʗ_g#'ߗ)	Mgc@nݺL,mGA=w7πJҷ߄JC!G(
5Ax&ޅNS]P6
nm]H@`Wp>0Sa-	7>m+|'fݖ;Tis)|>9zg
SE^IY&I4sZ;lB+ˠ mFDׁ	;L-"g¤vR_H?X/݅Z	:tNt|ȧ
|ը^T<|m_w߸M3%1.ms=}(hɴc;iR@NƲ/"Jn=iɅ\S>Q9Ġm5h9Sn
Rb![j|^[wL[|]5Gmߕ㓹se>֗m P-E/eJQ#C2/]lb!fYۃa2dͨ6
n[xxۭm>Ǩ>Ht}.&)ЯzE]z_T
h(]:GD92=V44ݱYq@.ۓi4~k}6[Ln4yI'Ha:P̸P9PA3YJ5R,bxj=WC9$<Pgv,ǒpYd}	xQ>lgߏSuT^_ϪeV.#
#_pRq.QWDW7fh݄fj
=vcs獵/e<x$3*VAJR:8MGJ2ItU齎>Q0<n_$y56d&

dDY!{Bz;^N?g4}k>_vJH^ҽ-emS?)>NC>j}TPKQ@G4PKnLargonaut/CArray$.classVmWE~&$Y.%@VZ
@R$PANK7f׾SG?ٕǗz33w޹/O172|*2dY6];3B#e:|;#1K;%OqaHqb4\?\
y:XGQ=|cp1ݷY`޸iBNrjA>e8Y\8&">T})4|Alo8|
_Ex%*[B0{r(~""

ur 	ڜm	ڐ FĔ{!}C?chҸqp둪[&?N~oQ75,VTF	z\rht	4#nE:1CH5i%#_}{#G2>OFHzr3S(`SIHRHI$)iԈzvj)XF㮪eAm	T
Rk;lZ/ӏt&&QdPKy8uPKnLargonaut/CodecJsons.classMOmKP>gSVPh(A0Zw:ܮf~T	Iy>J$CNC ̈wzB۔ӈ:A(-F쑀 ,3 c:i01B4Fh5'5[^ns {М"6=DlIƾn-YpX
4红kJ(Q$yooT.m>ؚmN#^"\Wb<DDa"o}.?=*
 KA!Mǐt)@PK/fHPKnL argonaut/CursorOpDownArray.class}]Shϓ`S@l,6Ȣk;u"IXi/:{ыjgnMɐ=9'_/,zOc3W놦_ִ
;W9ח;k2@"8p5r_FoMnrrlz:P{CJ	uzc*".hT,EDw%	˗?ɿP1U}/yr!XUP]
L||_Сtu9
)ŒMyr?Kzp~$ mpkLl\6_.6̤vC΅糱»1nd(:',j &eF;2" BԣČ+-Vj+sk(Z!~i"5m^VQ7yRXY1UJ<
1)|8*th>ҹB'{#,@/g*S(M[m2S"GyIQ5\GcY
XŪ%I;x9EefGmpaa
̒ūAL]әyIf0V=@h}-q9`w<.B6.ڙLg lI,ua}4xҭZ)s]y0o, ^ٸk6MEMM5j}kTmsd\"oA`;Z+i3uZh$pSIWv)z]4΢5JG]Ƥ#}XŮRMZarҖ[ښ=B`k_8ذ%g?Kee[DQK	vMUTsZl[cbдm۶$w6@*v\ODޫ}]U>댇:P^zWP3e+
Nu	œ'Ohbeُp䁵SO+hao!^m9(\b2ڒ/:CaQ.585u2t'B.#Xs8@(:.8@;4]h{6@d(xg0B1LPKxPKnLargonaut/EncodeJsonKey$.classURI:,	AP;`HuŕbD
I:8:&kUZPgTez9\ٶ%oeYknӖĮ1d^`q]بUWC!f[\Υ-Y
}cmoW84D^F	Ո6r:rlDL̝dn9Ub֤NͦtY\4uŚ4^=	f{cHaAoY5(/= ɆHA=6mIx
hS<%89Po
=B8؛*Gh&p! _7zi\$B/N)@o#|agFl	@X>%BK$zA|WJa$ߘ?>%V"*'>A(aw12xeP'Eow-SfHPmNKcnN(ܖD!WͿ3~h6DnQPduzyu>[<8+i"[==Y/(Fr)
nwmU|mUVTU_тM\\IA.Q:
g:֦'xaq"/􃭚h.~/wHX^8VtL~Qe%1S,UۅPQ٥"1TK;)Oc6SFsiX$Z[EE^VO%.1wVʨ	Y>	,;Ɣ~RXoZ
hI*C%Ųӝj@uvhrّJ/얲fhiqv
afGJuN=_$	񱊰2TIRmФ+NʅLrqD,.iEZB	z;u$
;BE<'z=C-Yq}*vr
%A7Rv
:HWZb|)(@%:ZTui±u0VT:RI
O6,m}Wܢ=z8Ym>);t ˫>Lc7Nnݣ)t(ER4rɥx7ԮTkK{q])+
mfRJaTnIu	wdI,[8)O[d[<_>-Kȯ.<8F,J<	vrQ_6e'X%gK늆ْ_q:ā}[PQ촭R>5O|)u#QG:^V$[H^Qa;p8Ǻ蔐LV:EP5>T?.b!qz{@y[v엕;Uhrůd˹ph|UAV06a>؉AoyvZvTa^UWUKQbc
}`_]oN	}Vȷ%>`~?i+'Z8GJ.{<DD=ˋR󂺬hLh*F&4/6}\ٮмpUMnR{.)qY<5EY1{pxٷ+<\]W1]n
r-ksM1{YVNRFoy9Gu-(ʥ!2`x$/)%@Cy͋X7AM_Zڕ?qѝ<̊om/)e$4/	{y;zkJ^yrDֹhQ}ZG[X0֟ce}M_7ܡS}SM٭ў!nOВS?,qR5:A&`eM`ڧ} 7W5_ءx$.d;#̿S!TzOw !	Ap(8J,qjGmY*&u
>vg@῔)

X,k0PpegbC\*J^ȓ%ѦT"jWӒ6/90}W9-LJ{)I9DAXFOޫDL"ivbX(k[唤I8z.t9ƛ{
LLO9|B(!BRJn]j|ֱ.;.evɂɶȅiW4,I m;WvYpBr>Pq;nؕMk±ƩlA
A
RR*Z}n)oX>Z*'T_nj8_RK|*NLoezR˾@Q:58.15oJXG
).]מ8U=yhzl\){k
S~
~겫0ur)[q*qGkXVe)d\qKS/v6	Au@B~;˗Y~ᴽ·-Ț0^UlZUZ+*r9dT\&/Ȼo!mYG
vXrܽx5rGcWD}quXQ?soh*~+۲h6R'm}
%%R?GJM	CFiq]R37tv$[pCPU*lJ%ѻ^9	@*o좱ƁH\|O.DV%qmĮ3|DOn( 碫:]w;lZL[ZZAMjc8c8\	;F@Ӡ\IH)v=5J zB|eWUAK}@l	nQR]2Z4T3^AMȩ4tP&M	_2iB\iq"Ald&>ҰӎbSÑյj
Ȕo xnn&L9Bff ڠڪv'j>rKUIDcn[L[dUszuA[=o>bxL4.dADi@sZt!2kpREp`g0-cyZd2"䤓3@+-Y14Tg-6æmj`1פKĹF2+&@[&]weElapEh(']$J3TSXeQQ-kc)KTf-$6ЀnclQYdjKCgSOP4Nmaa$WȪ,DdA#&b~t?1mh:9~-ίȫB}u9\ڃ_i2?_eY$1q,D8iR%%ݛ0V餷ɚFfG"	yNq"{@'R$ǮM]LcGޭ/BVVCȡ~&Ab6n$qXZSBd1CnMġ%ݺF>BI&pc`Et˟y^&fvǁxӕr?.O]Y$'uOOz`-v??%gɧYjhSC}V9bXKu`5SKEרXlO\LBČ1"/F_Ejhm;u
MYN|;S2:ߡ:w2fUK2/}ݎb9#!.VK-u)O/GAhrA40qGNi\-L[4U7NӷSO.ԷC֓kIK,'6$IA"tA?S01-&f)ń=$ǺT218QVp˵I&GU[Uuǀd}e}?ku8z`&Q7]l-":H0
8s]~DTh^W*<P$[#IqL
SޘJfhP`EWgIxٓQѨ6Jf}7,.e}B=z㒮PU]WBwzp3BF#R

V=p
AW^TMxm.ၷJx&`ݱQK:V2cw;AVƲu~}Q"E23yQ&1?Oy|TyDWOQzHV77qeLGqwD%-f}{YתZ]؏]evaiHp{WOO9%\X-Ӝ3bh?tmϗO9Y4xۍb`sV>!ဿtLyvVYAǤ	
'X"傟?wYA5la%Aay`C6ј0z-FJF'֗"jPgqV
N
9ź״<|VO9l:4u'M(
lU~*rZJHׁ
VA.x77y.4M.N~4Du|X\~]į[\9ڋ1 ;
^ln>l-NO2x?~Ω㵣1:SqT:L#s[d-.͌myp롓tB3kй+qtlu7s
Z
	Y{tBtBH'`Y'4N&4:ajv]Փ:u>nL'	Ъ
!y4\[jGz܎Z>;|BEi7ܖ	pGv$;N9OsLB
~NV~ʏSdf+
18M-	ǧ:Bǘz(a=IR$	HbƤٰ!iZB,Ng8g~縯KnM*d`3dJ޼}Z
_Wey8G6-۷4p^Wdy8!
xt89')˓	a#r|( 
s??	1aZ&gLk?˄yK;/RV)WRtLѯ})	9s	Si~ϐ>I~41f1`?ވ͐Ϩ?i7yt#?*?KdFkBC<	,fkZ'ﶱ UܲW,-z#YB֖ð$7hɺLq&.]W@B+qPڃ
wxA%!S-kZcTnmA{6a/$Zi^u#߻Y}575odt߷YL CلFلC;*#$ݾ/~2l=k72kΫ[2qsLY;nYaFj6GۺÈi(`8y5bNYp|~2OgJ4(
GLXLa=X˙.Xw듈u%&v,b>֛Mwb=cy\7Xi\iޓI?4U~hG*Xg؎^Dc32?65:tǹ>QLq/0q_AqߴLoSFΰ+oo.cl[[iÛ~NbL!;!TrG;!Θ3f[>C*͒)ԒᇆS5s#e
a#\#,zx>?$ǧ8?JYv&db3G<_&7
.'>Sc"q^8x%>Gu躊I]EFPԓ%B3g g2LsVSI֣a,ۑGH#D[({6;
?:ı/)yih&Tv\]owy~A=BlhJЯ$y‘,w8Y_\9߸}8)~9xG-y}kQFe"q04
DaA#7hMj4eu%!yȻ

ӟiӟs+jxkS+gqNז\{:cZ_exxKId?HݛUR`&^U8//`M@L]6a[`VuIؚuak8t$lC
Ua8J`[aM)mְ)6Y&DHID8μ%]#IgMQ}zGPv:QP5؇LXavtS~ܴ[KKy8+88Sp>i8W-qnMLy8oI	/ѷ{+a_ جx{TJ\~R|q9`X*[bu`
X[)7`VX	qk[`M
X+~̟Y
?UI1DǏSOa~o<ߖ~N#9~
)$?Ud~"IJM{g	 <#eS.ȟ_[x_~?le}S8|?V(IPW~OBA:uh7i+j' V,R|tijH;}0`|\۽?j=I|ΗK?.@?W
6xѬzuNx o	kTƷJo\L5JV+EWQl֕tj*
MBwapHJTqI&Z1fo\dS$2#*se&2;DZ?\01؆$&${1o	|8=Fx+m$빬6AC:!FLB9ַ̮_7/b٨$ˮ^)<67hޛOJ> (T/Ⱦ.PyʄP'^sËZ.}!ѝpfRxX	#ʙbp''0Ok3\îpVܞ222:+ʣͧ6@n0Po@J4pwe>
l	L5I]mpD$#ANOq7QYzESa6}<p;xUSZo(VsFT,64t"~sku'w!>{YL(AutF,W7qP`UsBlhQ	;O̝TV/eaL摦["(('jEJ$A{ø[``yT6šJL(L_veN	Lv	1vu30AC29gޱ!	ꪹBv7WpOeQbB]󆉿j|.	Z;wHF[Bn*b^s>sGtZKe@JiT{M~zynuSWsۧGJ2PM+9^
0K`$BuC?hKX5vMbWͻEr,"yZLPd$[<3ERM}OKZS/[)N؅Dv7ؚ5K5o^"Nx;cP!l.8ލTFkCSMKsųm+m*ksC[%0=s(.nN5yt,_`mx `rqSC!t"HFk2P]Xvꪮ%G4S4Zxs3m4ϜU**&aR}NP՜~9;$.9X0SO6;s#~Ā]FE5t`l1A4w0=`_O6wx"l M:
aXF)~w+7ZC+EŻ=,e&ģ헇/1M?$6ZL驙O#t6M/wB 0lZ봣u-u-#kHoX( )_ZI[@nu[[Y-@!7Sԑ~a =	`v`63`q{9B{ą0bv=5iJT8/PKU}PKnLargonaut/JObject.classW[S^[Ҷ-ld0\ȘDk@8-	HƖs`!tCiNL//LG;}i$q3{}k}벗04(#]SFdi=}f'7%]sKeΞ2ʩB5)b"[VHSrQ$@ӗZ"?v(aK{c?qRY\=)8‹:e	WFEqPQ}\}dPv(T)NJ$:Xxy9ψ3GAQNٖh&va뎴2cQ^Y`s*O~h"XxHؑ,.]21QH/Dĉ|.SxO%)`]o%&DtM|4gQ>,)(OK-
qn:(3N%s+a];_DˇKas;AMW*0_Gݢ7=dA
d,LCfH੟qxc32?
yoW[()En&h(^?9i0r]aAp카a֙34C)}ɲR`,q̰S:9BCuAc=k+mK+M=Gn1ic|}q ͷ`~'O'.xU/tCYE❊Cm|_?OFqqךT.&y*_ MY8YwĒsehe1NLO-?)f֗3|eiHså*v%6;ȋz0r ٣	WJc,kJpzI ػRx&즲^0Eb`	Ե>2"xOUhRyO7.5aW$wbEEnPMueLk7+#Z̈́w <*c-}5:	pqDwekyc/8+@/Pa?	
e՜R>5BQVľ_(rƞ ЄNJTю"[F1yA`cb@.lo_m؋sꙪsߛ1IhYblf-]dT 0N~5#FfYֶ	H&_l	P"VuB _T̓3VUXn(ELPY|3%Own^Wou[FEma
}weo[QtW)m^tWV>KE{~P2oV}Z)Oՠ\[zQfwcq,X%SxN>~
{
DߵHLH]P'PU 5oOkB)[F,!g	Q째hZJ:b%$UiL
PKM]PKnLargonaut/DecodeJson.class=	|1l6n.!$@wC@8IdIAZ֪=jkkbQöj[}3|3{og;޼;B(;Vz}5!3,u7wV
x6[G6afFN"\2b:䓪V]myc#>d9b˚,v{=:i$$M̛{Nƙ5k	rm5;Si
{Hm~\S&
.)1排ٵbZvܩ$ݶɜR&dmv e碢BEZjwzacu+.r7Tl$]g3扴a؋âٻ=C&0ԂEK4qn	E}21189ޔ\=K"v^ir,4B,8i訽apnRQ[4Ȭb{&4$qԖ+	7RmesF+N9nsDZ5ƉKY)q:uUU4lޒۜki^9KY^lN&*\BGڼakl`̒
<8Hq!
-)c1Lbi$%MpibɁKmY,R	NQ.:-<7]0.,Pbjiޝ5c)[Sۑŧ&lUi"Hvы
xp:5-%syqWά;jL\{gۢjrxVں?˹flQqmt4W$M/fwʲ"h1X-oncm˃L;jn[*pTMvZEGEm#s9NmmUNv/pܝUN,-H#L"HQ7VnۋsESephYtӲl[GNIM92͢ձeMpLmXvwMܶ9]f4STEs@6|yP,5a5ݩ&.&	\oƭ[殪1]z͔
A?sϝ
Ro*v90zR!z@ONzM"=η.$9]6[f~ZE6{mKZ48)6H/{=gqNo	ɵ)y+whk|1~ݙiMBJ9l_
>gOi6.hrY,lsfe6tBUzKlFox[M}R6n薆t5nlѼgWukY{wvU,ްCYְngc]Ż^,(RXSv8'cvI<+Ts~+zy98mo*pVO-ߖq"MR(JtXNc,k!mr0YvРݶdGJΪ%SӾ56w+dZWECYuwl.AsI6ybKeQzGZqhxc*5]}bG*#)<u<&
Sy yng|6-c؆ןf2goP:2fĦ=EpEjJMn"[;jl3FstJܢ"|Jfd:eF֨j(
?t W[uQчe#>qeʱޠ?0rhMPx[Dm,mƈxࣇ}>cG?>c/> b}1>c}7+rո/l.kK乪幪幪幪幪幪幪幪㹪㹪㹪rfԎy݆;ڊ0ӳ{QE"ZYl4g4Y#"?K;#-3/$$jbY#]#]?$>H|sr\x\U󙨚D|&3Q5ϕTmE{>z.L=R#54IO"
|iHD$X_򩭑窑窑窑窑窑窑窑	ȥ},ܠI"Dw-3/lN8Ciu|VGZiu|_=|\\\\\\5\5rFIԤHODH'b̋18g%~Vg%~Vg%~Vg%~Vg%~Vg%~Vg%~Vg%~V,	z#xoyNB7IIIII5r'V'';23Gr.V˹X-bq.VǹXbuq.VWgŕx	s*.N>uEO><N_ἣ;j9弣Z;j9hKwFýc>Ԟy]ik8pL[Ù3m
wo{j5i0tS҂]\]\]\]\Ņ*nlfp'Q3TST<x.Ɋw᳙'_ׁoT2 rH\^\^\^e?Z᚜-c"jR{Ѩ15h%KzhkC{'*C{mښރehӠ5)P8C^I	F0C^I	F٣1qR'60ZOSHu&agoL"mA`|=_`H9^im"C$:	wO"A`d̐2Fiq*1CI.	Fk'J:H)
&п{lt'bL6N{CO7t:vCg{Bgپ@l0t6:ΆCg#Y0t6:;`ſo1~7ג֯(OG$i4a[IkےYFf4TfF1dFIqY,XCkZŎq2I3-dzq9Fv&9!;iЕvLw9O[}G?#VZ
J+
	m9RV"	rjD`-`aλ_Bo1dȐum߈yGt+4°
ٳaVMq&F9kZxGAO~,;N6,k[.2x}ھ^XZiO`$ܭt~m_h}Zfd@dxWހҹkVz8FQ2]cJ#Ahg)`pPȆ+RC.SUtu%X*=ʹJ黚|T:א*V69+]7+|\ύ}Rj;?t[|g*cG97+]`V޼ G D}Coq0ZɭB|V-_w(j2ֱQ^;ޯbd
`\
%!&Yb$##D>68&
9UJ"3ԏ0ܾB+죊m%O({82Xψ<F)atz*8.o?IƉQyI4Dȷ05Ѐ=J.F†̏G^X3e
cGYmf'y@%>:T)7$3÷;h&+90}Կg%o7-u+-߂@L~,}I';w[,Pl@hA`hn׷W&$#3l}QhlB&+3$D{nl[64eB-+JZ
iairfH=nw,=?*)aG[a͔*]>ԄQZ_{i~i{K&kȢεRMV9t3dV̭xdD$[-4fCr=
BtE3p4=s3t	bLU1	6/ ux{|An/+Qi
w ir-QRWҹ݇ZqV&z
)EzI )6B{lhRFF]$V.cFXfG&z-Ap:|—=^Oo`|M}_F'%4'OoB㟜E?kG),Rz,8hn*U!@oeB܆QNygEm5!~joMxo"|2+`;yM&-;rcþY5Jnw|]ƍQ}8}T!(d&ɛI9cD/1[a;{,u(>ΗK>
IvkE>^gٷogWHd\LNPMrţ!@V]E?#>*jS+NU)lJvX4?.r|H@).bVU;L^8-yBߡ|qGfp_88TγUOyKQ'nܰgP}V/y__!135MZ诙L+b@t:wLA#`ҿ1R?X=fGBiҊjE-t!B!컛30lF9Mr1t
*Ookl.B>ql'p;>2;*8a0'bY(`7ӄy(+Ca" tb\XВvX(Rn]5
/@)OweuBvz`5gn)i^-m@^g+BPkYB]U^*H/z 42GkGkwբQJ
f4B{"]<tmFBgrm	-Jֹ|}2;ÚS#P׉>ʠuzFkFs֢ځl )vvX*tC(c:l5\J#Y%Ie!{dY;!]g2J,HT^ۄ3AfpN,?,㳨ߎ2,boudza*-x{`oNͩˈe	VXA?f_F%Λ;3Hd&XR/@j0d<_"@
!9Af1.w]XCv܎lVBF@3vd\DSHV)M؍,|u졡qQV&*ba`p	J'O1ne>*\9糄k(!댶2'hV_)fˌ,W;#٨**ؾؾ7K͎r4YxơA;ʥO[B:[g
sK˥0gJ{)lC'!>e^р|T$a~wӞ@ 8B6CGÞd>y8+5AM&dzM#Oђ^2$_ljLfdnLF5~-B/5L)%S]2J-j:L_GKUdJf=+E=ܓ@/%gI&RfbJ8_ qė$jI|HcFɨ;kS,<5dO/<>IHR$F:⋭x^>+FQ(ZN`/0bzFE2{-''(QeLrd!Io9_t#IH'b?A1-
,Aĉiߧۖ	~W !ӊ_:84W|b#'FSL4[c>zvB}޶ߨ(biyG0`KUcI#|,Bfw*by+)p=z^%fBL>^NK3pgLzA=o`{ҧ33~iO]^d9L2$`3,g$C2?Ds9!/%SqLp?=vP˞~&({2Fo1z$oўw,4'n0rS~ӥx;xKL8"hjlcz*q^c(L?w19^s#709xj/gڧLVԮtT0IIII1т'cJN1\}3'Ic.z0tFYDPl;DƝ3[j#֒W0㴫ة#Б_]#x-Cw0*nloiKI/|cAoπjwR

w',>vѾV JoT*ti *9YmܾB1MޫM\lp]ѱGj-?nQfȷ~l7TDZ2,F雂}PpLJ$1(%.5goLxdl=	`3Ȓ`\*չGrT%Qw)l*gt)̟ь8.*$0$Lqh)h*E~ؚ"xh`L∙vat"B]Dfn,X~G#|=Q,c#~ICPmxGG}R
-Q?dZP eC_&P$RM2!v$hoʏJ8/+t#av:Dő:LG;9\G#1pvqu89;8BBGرȱQ(u9h݌|@%P<,((((XPP
 jjZ,Xpn@+
6VupvT47Z^ڝGMk6l
p63	p.=}>}A)7O%ZMAԭGESC#A18p.y\p!E.ES58Xi8V;sie
+>A|*>Qk>p-^ʍ蓪Vp\7mZG_jOF+V|
7|<|Vn"2WdM܅V58Xi8zJ?Zji{qx0#_x1xRi*}'pcK?^JY;Eg/|[x%|{e^U%^̇$Gh,X?x
%o	+_,oT)ہ8.Z	&K8VpDWO]?U6`$8NJwY9S=P`H,iL3UiP3:X4@+?dI|Hlvl\<|Ysd	,G)!	qO{1cЏC?fL:.KTPʅce\f-9ޜ!zC=POc1ӸQ/U9C9(qq:WixPc1T*w;C厡rm2wqʝ܍MZOgx
Zu6l9ƛU]2Ψ㳴GfYf,n0jx5<C
;d.vU.JQJc!xԥGêêêêê)^r148:t)a-weiFT>1TsQY ;#AmRLXԣPc92sy*pqZ102K*VJ!r
F1暴.1]T1!Q8ZLCZ4XFN'?RdGQ>?M"akf~\;Fμ_o0S1	3oğ4iLS̛gf~N;3%r3iy+`3S#g~	a0+ڙb;W
fޭiy`ڙi33δF|65șf>9IuOkgfF|?k09̬șf~K;9EδG.hgfG!~`援3s"gl0ڙ3_3̼șįvfv_ԙ-P8*qO[Íao~KKKKKKKKKKKKKKMh$D˭C-dJ3qr:NR|Ζ̙n>G3IZaK,Z稅trܥ]
f8'Zʼۧ7+d%^plrTdqaIy2?#x'+l-'H8.搹*CGb@)c<dARTS"bkdnLW&Jh.&%-xHBuEVN*Tj:-"V%^Z@T^XJ
P!*?aI"35~@/ڈvŴX]EX[VL
q\DH1	N#/GT]aLd)pLS1ZZ8`0pH;jwnL0p``P;OMvr~g&}^;4~FmI-%,DځYvyj6t<0Nwi=ܧB@Ij'"HmӬ0HQa[0׵#W|))#aNj0(+K$ ϩ,5$&LJYw˃ v[Er;y	aZv.#g)M*Բ
GJ"NA13 0 ':] y58?F2yE'`rVI	zʔ_?An6K~MȊݎ(h>ws
+59̲^`T&zw[=.?2ePF9zLh%ʠXR^F\Xzv҈&;F*f,=:/LگePuPPoe*vM"/SC҃`Y+wwzQ
Qu=!
Y+TPY0xd
dY!Y!Yă[U2R_G/ѳ׍H{]Oo,ϣhPU-u3EH@oxLy}~=`J-ꫵ
U&שޟQ>.2#~%ćZ	CYPs2M"ӱj\a!P+)UR[dJq~aa9Ċ-D&,	K(Z
Kd!jy
мG۲U
kqaqaSƅ3jB.	3" 6L2ÖQ®ey|δNx!>[7t]6?*v&.azvؙE€BPS|zANUîJ #x =v4Cob(*4*
9A Ld)S|0'9!pq$
;R.i8|U/..00EbYWѫUnٓ2H@fIJMC8,\tX:2,VT |H92Yz,]e<t@}'iREjTFeNMi
׏,>i䍰,{ĭ
gC
5T=,|!i
gOPM[tٽjɮpw(>I?R*0d£FwNrdrۅǸPWwxB9	Üt4Orғr7rC9)ÜtDN:z*;Uzo(lgagQ-BFp?w,qX)&,f"`
*D!KtȂ`95tχVm"t9ԎwRV,UbW6>ZdwDT=
3=a#Fh]^2	/?$8+]V.+4zsD^!X	nd+pa+l_=6ڶUm7j#
a:jU]3υ>'}~j[KԶWuƽ9Nh3M,6",-Sv!{Զaס!q7nQݯ=)5gu{IKWrŷ5R׀
~hFΗ	1Ŵ$_'UƎ࿳CMg
 u]{nG(B-YYYUYYɁE&f;!m`0Ko+0[av֊f7BVU7f5fY֣f(lj_7Ȼ-2ffTy<dOgLh p3uV{KM;8Q}vu>zd:[N?PK9D'<āPKnLargonaut/DecodeJson$.class]|Ev%WB	4M%Ѐi4k=hSҤ[y
"CPyC%>P@T|Q^"of~^\3~;ٛ{&&LgkwW{Җ-]ɄRbno?}ig{֥6mOlL	d
z7wS@{Ldn2F׵l
P2/v%37lXӒ*dJ@]ySDѹWrJΎC(16R2IR40RLɌ}]vM=,\ѵu٢ %R-wYβ|d>{:DJ)зiQR^%Szts3w<%V0Fe2!@&S2h7%
VnK	HAIZN~Z>RAsU٭+{z{d+	A%T˄D
B@^©J+Oo&5(5'nо"K;\ؗ_O{"
W;\+˿m8bNz!Ekk9Ts{>鳰gGmIGG0
ɻ%pﾚnӻώ=V\'vqmwԠ!7rɓ(ܦmjpͦp6y壧3MM)착QcScn65`'Q>	InӧmjtbWA]_7ae`1^YO||n|b'Kaiqf`YJn4YNjuy|@js1ŵ:njty|@B+&nW5bLJo[aV4^g4><>iEݣ1iX0hXC.y|ܸ>
{PcXӰ0OhX8<>s|~=aaa:<>va187	a'KaaM>M$0a<<\<	__r~1a<<\<	ܰ5)OJֹمM{8cKks"Phxp9o8
vJN7x6)X΃ZO8VWx
6[/ҿ:k4cnސ߬ r9SnnxH]c}Ͱ_nZޜEqj <驠Trq,&$'0Ꮪґ2n0=j#K9UBQ]Au :0XL61H30sx*땣()p99;ks>l'i qfbwBgyVm-%ZJ#XJ)7pǼO鮁,f,qYA9N3g
{kGvJOP<*-ViqJUZ\+Q3OL80 7&*4s5u6ڡZUjRoHi!Ro؛OMq|l-+XĹZm
揱3o`BSkH!%xPă:%)NuJ.)
3.%6*QJ$mT"iIHڨDF>ZjF=Z0:G6=Wf݅g|	u]|s|v0cT=azV]F5BרF5jFV5V5V5Vb_A4%,'|fq
}t$>3v;ծR㽥{K-5[jxoR}ժZժZժZժZժZ:zq6{Z$.zٯ/C|H^a~D_U{ZU{{#!GH=BjR
ZTTTTTnvȷ%B^a-ޛŹKf|7ތƒc8)^թ}Qթ}Qթ}Qի}Qի=dUUUUUUUseLaæ|ku$8)U)US~E1SXilWsaWQԞAԞAԞAԞAjV۰UX*jV
ZUªVaUFsXƁ2FI\?kܦ:ݦưZ)Q'~Q'~Q'~Q'~R]h-uբZUjѪS0Z8zolDs7ZX-ɿFX(t7Nu@OIP8g.S{]u%DԕRWZJTK]j+Q-K}PKYz)K]/e,uR^RKYz)1rn=	s_>Z)ɿVZ(D?Ph|I/-sI1P8'bK]]l-uuU5K]f,u՚ZUkjRWY5K]f,u՚ZUkjRWYUkAĸ!ɷ(0K
G8?#3ɬRR4hc{}}c6iI868^FJS#Ml߹=Ӣ>28kj|'wm;*vFB}VJ.VkԞY12}KWHB
qWꬦؘS3>}ʸ
I\;;îe1s6R{q97aвҟiqen(e,e#n=*W)8DGV)l3]Z?Pq{CG3@V	c13\ֻLͽj{m͸W>ncQn^;]?)jBT‰q!ad ahT3D=Ii&E
.;YCNTũw: gwGZWDq>W*QnrlQ!ۘ^ wr+~^f6):ykh*Bϴk;q,mGT˛ώBf9ФFaҟ9]c0Ey{vA{;Tԟ9]<uy}@wS]_hϬwלNfi΢~hHE-qgڿ5{/DPSy6B!,d3)!njM1
b:
qGqDfW~nLI=U[D,-Y޺	7pAP2-Z>40JsWz	)nĕM2+eutM9vel6=Y@WPdz'+#+2Mݸ)˫9Yq@^{t]uWeM&+G=qWftdŶTbi%Wz#+u_0wuwp
EV%;G 7|q?׫]j^|l𲱌}F~qB
J&>n[>oͧ0ad%d.4sʻ]|ko=۶L_I[Bw$@a̿)!GaQ_@ʷo%F&or`!3-I!Huҟ+'2|__ |7/-fƒBqN&/pBMp3oAflB3GѳAt=Z|EZR(d%+<{||c㧤;̿peI{'
|toqo<b~!g3L(::nذE\[QKmWh>Jٺ'͔}63\×$5=YgsbuGgߚDD/%sCtuvt%tMɤ-ʉ!L PA)"3,B!ψI:l(d\M~;%^"|ŕdy-5]L)#+dJ6k+9[%[lV	JUҭ[%JNr_ɭptWM8:][ǼsOxJq_mptWr;]bGh+}%wJ>羒Jr_ptkWr]G7MU5ml)9]PCU|*"$&jzH(5wbRO
~B~*N3'
_TkϢj3QLTm&6VM~I%J'iPWg_3y!QyTDUMTDUMTDUM[U{r5J[(J?'$MENSk)z^Ez^٪ː1a~S0wuiȕbfʔkДb4M)FSєb4M)FSmSD
MaS4
a؟ȟa_&1uaii;дyh<4m6MCiдyi"i0r4WF%;yGz;D-I7?}'eiuhj	Z%hj	Z%hj	Zb*rtF/K'

P2Sh|4}>>MGh|4}>>6]ޅO5>O ˁ τz 3"E)BQP"E)BQP"E)BQPPP

TȁJI`LgY)hFh 4fBY,@h 4f
ML
H? 5$e؄eRP`_P!TeUBUP!TeUBUP!TeUBUP!Te6T"Wg
T́ۋH$Cl}B[-D"tBn!B[-D"tB:=L
	-tW/x)@g@
{{B@(e 2PB@(e 2Pl(Er5>.@]5{ρ!C/S>b߅Ж#m9B[Ж#m9B[Ж#m9B[Ж#m9B[ЖЊ܁+ҀyMHB8Еtڄb>849JA}BDu"A:P BDu"A:P BD6"W9$@?|H84$/%sCH1}B_W }B_W }B_W }B_W }B_WЋ\5NxR8t8.Wy ҝ#shs/+*JtE%]QDWT+*JtE%]QDWT+*JtE
k\S~,aH;r,rZ^!ʭc)׼aߍBTk5U*tM
]SBTk5U*tM
]SBTk5U*5"r4NzJ8yI ;эó3ۧ|n!N+)U`Km$=qI>]R|I?ItVҦ6!钶ЄVRGvIۇtI'N%8g%^K:eI?Ot*=M+c%9_K:~\+B/%KJ0tIK..CHtIWi%]]CHz.]5ZI_.!$:]ҍZI_.!$&]-ZIetOtS+B跴.!$.g^JCe^NcVOK~.Ys.!$.7ZI/e^M[v>|sh
}5o~-9̅
5!y߲M&|(Gߔx䳱yM*&?APmfOX&*gr&}rbC>ݤ"דN\w{CN:&OmŨ|1*_!'&9ȨQ̘Qt|#98ؠ	UP	՘PƦ؜lsq4+AJи6
rb.Mƕ04͐_JL/J'tO_dj*5:XY)k)_Ɨh|)_ANLAD_R6_~,e{觠e(;:9<>axQ'FPMPLPELP&5A w̱8f}K@TQ^17~tN5~FTs9jtN5:SΩFTsY;|"I:mΩf[sYB:/SͶJTm9լC:m>@*rK㰷Î˓!mH	HC
iH!S8D##CHȋ%~$:N@p4#B:/B:/B~;I:/NSBT;M:/N3By"1ȕܙkЄ߳C{!At!THA:>
c;[:v'<W`O9w]:7HatnFѹatnFѹatnFѹavfܹҹavtn}Z:7Η
sB0H:7.
Ks3ҹav)w]"w98;@:y>
|H@E.t	@e.}A:<\/3r~]:	M&t~:	߄oB7M&t~:	Į"eMj&E&vt~V:]'Įob_ob7H7ؗWM"Uȕ 'gB\jH_t
k!]zH_v@]5AE3A-ĸ}SzTiΕ}X-®ьðHf$G3ьhFr4#9Hf$G3ьhFr4H G3]!hfwIr4%9=^Ifv$G3hfߒhfKr4$9ك"WCa>s!NHwA=tH߂t? =!Hm=&d!|iqeXjnDzӂiA yZ<-H$OӂiA yZ<-H(f$yZ%yZc<-qI$O$O{RX=%žiaH򴰟H򴰟J0`_+tDOCB߰	(@! =	H?$Cz
ӐH?3HB sגXϐ|i.ȵݮՊ)HV$W+ՊjEr"Z\HV$W+ՊjEr"Z\7+%Z\EIV$W+{YV"^jeIrIr%Z\\\쏜\"&_Cw.DHCzҋ^2Bz`	Ƙ`		J	r-)! ??`"캑|_ "H/ "H/ "H/ "H/ "#rHE?$"쟒|/I$_G/+a䋰w%"=I{_/bIA%"$_$!?!8`wHp?b&`&n&k&hi&e9&b	&(o&(4>Aն"ZM/Grl
نlCr!9ېmH6$g
نlCr!9ېmH6$g
f̀\͔l3fIr$g1[(l3HrŒm\I6c$g$gQ"f%9یmޒmF$g$gS\qk8L4;	&ِ ́Ti.$5PL482 L17
F8kY	!ё$?_4`v72Q"yH(7"yH(7"yH(7"yH(7"yH(7j"$yF$oX,5*%yIިQ%5JFjIިQ#5,IިQ+5BQN7jKFIި|@;rA[EBK+FB
BZbH@R5$6`L5H30L20
l,Į&!$6WŜ~[;KbH;!cH;!cH;!cH;!cH;!c1'r+%cF$wX%3VKrnjC%cF$wX#3Jrnj$cFD;f.3$cF$w8R;f%3Krnj$w3DOTY!o]KJH-VAZ
PH@Z0HHC::H 5L442ďHⷒ*W-ǵNq$GǑq$GǑq$GǑq$GǑq$GǑq$c%qq]?nl%IKǍqc$%	qS?n]q[?n'JǍN~\y% YG 8Hpgl&fT&d<&c$&a&`&m&j&gY&_لnöQuqF5݁_c&5~w<ddы3JٵOڧg\wy%㓺ڧ?d冀|@2N?b|fpӱbAeBDM22Ve\^1`|U)~G2n~\$v$	M)"Vcb2_M`(v{͉ĆqbE4Jl?%v~;|[b,ÕQQS(y#mV}b6Ol!?kv:xX*^WkPb$wGH#{ш}]Ğ(>bK:m_,Zp^LNb6S,<[baXX-Fg1#&bxcG,!_W_|'OTۈ}R"'Ij=X&bPTl)yPKe
2vPKnLargonaut/CursorOpLeftN$.classUkS@=[
!1KODmA)R"3m[m7tàȯ>f:rg[3ٛ=so~+*9{uײZ3x^|H%˒r\9ξ+LJR:C6b/G6qj`"w8MC=D*F}&~ѿ/'a|S)(m/Kl7K=%HrniPೝ(uq'b2"moHipƒox71Ҙo-F:g}ÊM<{eQ4فl`#;J1]:h^ḧ;4aIPKBE?PKnL$argonaut/CursorOpDeleteGoField.classVSY?o_yOM	1"!:iP	>b|Dqh4B3љR5fv3[;U[~ըl2C}o{~ pKCF֪jIդXTK9;dJjYvz,ޯgWIKjVmoBE55FeNuNya
Jzz^>qɧ{_7"\r5Ax*	-wPƵS$QpVT?XzBn`kpJ	N{1tK82w4oLdc'NnnOeC[(I,剃<iSllPe76q~cZ>Y˅9}ψ H
a;KPtѕZ&EΧpDp;^:(J	Ƥpy`曀ॶ߳,3pbcs?%ұrغC,]""mJVюoXޚ8j^#ƘpAwpXۏo{[T\<&|AC*J	`ir<9>E&llyQ@mKXj]:\Q{p\-ϻek;w	O
q+㧋Tqqu2n1s3R	D&_-o:'
6+fdYx%
TVB%Rmb}ި(j+owմ֪zQ ?'p0?f1t(@x\g-|zPԏTJnP[-6*Yç+nM>Vjuk\'pp>OjUX)sxrwpŸSJÆY5F]iFVL6,,QV>Ph^ԇe^լ0;;JN=Ykk֨'Y,;La~^,v7-|h'[ZFUk,Ϋ6]kGw@I]4H95EYUdq]mteo̻	|D,aI?W!S[dqC)])$+qy>aB˩vKZ=7u-N.},xՠYwlƌYf-j_Lezx:޹ZRSʈklhZiAQ7M ihVjE%SRbE}(gԚԕѪR;'[xZUFlE(W*Z0IUJ"UkXg aю̍N
|}ck%1AxMb	S/n}h4`n?!!Ȱç
h)[Ƨwa
mw,Zp~.
zcfD\RؓZPz9xSO*Ä$9	SV9;['^OI̽ď0LB
G*`J4|:?\lO<3t!e('hwjZ8,*aE4T9UNjyp0{~5ĭmK<#F<76FV:ٷ|H\oEy#g^Q'v(okHd߀<=ӽ@]p]`G{l98>dX0gIizDޣ3PCk˙;+sGH򿻒`9oO-&A,Pb
똍:.<"FvfiGf^&dVydyԃnDPK6q.	FPKnL(argonaut/EncodeJsonNumber$$anon$10.class}Sn@=kRچKHR[KR(\DJB*iƒgv̜=33lD0JđR
lZG}8PZ9O
as$5t lݞ."ؗQL%n@P@[%\o7&z'VU<~,	VCmOylTMT0@tg+kMhԧ3KV-
by#'2|	s듞NܶPM+eaK	z6=Ep{ˬKc|\ֻ߰X?ce76auSj1gyJUy4RMl1.1]ɅDxPKAQ
PKnLargonaut/ContextElement.classUmWG/ AѢe4`TJJ&YEHl5킋]KcrGkINsN_?βR"e;ws㯟ϠN`Di2C7S3[WUt!0p|D~ݬU<ͪRW[
cL"TVRמ)'IgqWmdžZch}]1[
5E@<5&%qR)&mxi5_=6W63D%zMP.ǜ(Ig3 !i"jC$YyHYYS2fy.R9h/ax>^+h-,q͹XB]Le73>#AJ̭q"R)$gZ]ss"k+Va7d .lVFwY`XRR+CMydVܖ壶N*rʄťGBg\`0eHmMrRqQ4#j}Zv.9\SWyA$JTី}5NEY#qUV]U2%P+j{rLhL8B-l*ר~jMX5^╶fgLN=Le\EX֝>
$%e:gƙǁ.0Ӄti:їl@Ox+e^^wKY;;Jomȉe78KU	dz77SͰ YPKoD[QPKnLargonaut/JsonIdentitys.classmS@w/46<"@Щ2*YBGƹB(4[+g|C9nZ@,0c2o{0IU]G6ZuV-ǷO BHٚt#kϏ{q'kf5zA`VU@O@|w2E%0kg&NFdnc"pagzj0&
6SԹLch/ģz2aH.i3`.ޥ2|iybYzUڨ62ٶ.WxXΟf&^
GA(-##^jl|9ʕbs#qֵ2|+0kU3ȉf}ԁYS)9KP(1LiE%ẲDoK@E\.]]B󲉪3
|'!3WnACsUP;s;u@;"PKnLargonaut/CursorOp$.classTkoP~:JِԉJAe_%KQvKiI)KW9%=C&=v9C{ÇYzk*CpΡh"H}67³m}m[P/a7^
Kٓ;XChV<2bX`H{FahJ>,jEձ4XfP#k@^p]ySEO8~sRI5ғSqkS߷?QƘ6?hdh@a[1pA|O7!5(Fɂ,WN@F\u%-NMD
NuBKv_Gn
xO£hMwuĮ0#PBosH$i#Cv4G@`p`,!9V"G4##V@WZ4^5BIKc[|?앑5dU79XS%íN]`CY9iYm,ȮMp0+aWQ*Q/BntRJUtJ$!ǓrR67H#`x&#
PKSPKnL'argonaut/EncodeJsonNumber$$anon$9.classuSNQ]^GۂoHն(_&C%!ː9\?g7M?ʸgRh˾:{v~lD0JđBz{2ՄҪvGX8PMHLtskPD
	+3e47þ:{d&SLX
OU8~,	VW	mOyQ5mQP<ѡgr	]fMUMwuXEP:Ūˉe>jWE	6X6.ö0[VBf.jb_B)9Bʯdtފ@e$>JDqe/_z)oSD]d0,u]+J< ͱqB#ՏXUp
@]ap"{g<@\(wXvi$}B6qnOg&\PtN>-DaOIygvQOrh	nD4@.ךKLO%£PK"(RPKnL,argonaut/JsonParser$JsonObjectBuilder$.classWSUX$%Zڴ
Bk_ABP>nv>ř0#3ߜr<D?hfv[jv25M-8bsO7DQefh)3]S3kk9w3snSC2.IjO@^Ŀj)C3kf!'=nԋZf 
v5x(V3!Y嶮9pEEt1ďTK+m ߄UA~2JkGJy=3tSw:]S5~aB#ȉ5$|K71HL1)<+6'Ywz35tx7@P}1\n]SB}|JYjos*.vuXg'N
JZVgjҏ1J˕xW|6!{*ɦ.W0bRZ~0FS+)k1fQtnJA,onYtJ
htN	"bw~N(z맧)[pH 0ɢ2˸Bئ{U	%)#y^۵fHce(fk oRGziҎ}0Hԍѱ}|t0buӁaiA
+¤g$Dqb'ON(v3x`vC
=<qhKt#72BY_!3%j!uMF$CɈ;N_ }3=1L|E{I̯d+}q312m&xށ6=hT;"J!mF]-:M6T.G]YLDidpcPKL;PKnL!argonaut/DecodeJson$$anon$2.classXWE&R(H-Tl@Zےbm--P,_պ$.Ilhkoϟcs<ޙ>kf}wfdm&z%M)GL8,g1t
r*gfM)Io&>1иrtU6y9CLROg3}v}Beh7FiJJU%'*_CXG+1Ԅ]ZlHtaEC˩:#KZ>YWU'+$Rafe'a#Z@C>& %&MVtTiXś9%[ri_%\%܀?԰†~Z9g&iuem.nDNPڙa	ۍ"CFݽFw>*+eQ4ǩ9A3,Z~$܆\#ZtJIk̭hqTg%dQsFϝIX#D35E{cdIpCX^Ck9LK6D%,̋Ҧ=㢟ݼ$*ENE\	85q}Sf^+׺\Z32
yOQ&aw񹹛asSa[A0]$܏Sd9-*$=X4J%1RD+ >N)vEָ-|M@!aG]7jvLR$a=B!˰մ	/T߼7G!hJÊ
"֓RIBa-E/%4.PZh-1Júv,?$*HŽ34aB{%ˮNU.WbB.'Ob.nw&ANuv<[ВtT`&fF
P&h+׏??0=2󠣐 ^mSscwSe„4fy
$>Oi|Sٔע0cN68l`sϙJT=%|gNY]]1~Abl@jsMJ]tem\^3_ڣlҞAgfnVlK?eH`|Lx<FJX|()1 NXM(oWI|G3ku*z~&
T|kzW硞ؐ(ݑaӫHxM(Xtfq]snADU`#kL4KmYw+t*Xuv[Кm\xJo>݅vA?pfc?pcYBʠRp|c1+s[>9W2z[x0xƺϨr`\A˶nn۠1XpiԵ3
WTw:|=hߊksfp᪓yBP]0-
MQ{e5-KZ!L2>\c۔ŕ8y7xjgLUaƃk
ur@PoMRVL	Qg~O>Oi<#RXũt9]Ieoyb|f-Mk/;1WqTA::$B?k\ruJB5}LwZtuK#=C{$f:H6%Z}JP#T-4MIazⅵLɬR$aRc0vlԸt%~Jƕ6۬wRTSzJ(YgbpY>ׁ
48cCtkA._=H	”dtRR_zURD&fF&QoE<%^aW.Լ$2LwIs3F8H9>M(Q{5x`oxfii
-dTiEn4$9Wb,ihhʆȀ(%:@9ѷuy`pmtzd!nhe\G%/8Rd]H
߸:ρ쟋G?Fg\JInD!`Fkq-^Bzȧс#`>+.o@?R%~nK]͈tk֘RtJɤud$LJr
ezH6s
=Ao†d
z}фA<$ ݔB{ׇwۡȶmPuDzp;dVETm{Ý5Cz\g$DPB
Tc$Ȍ.pgJf(t\=21%3J4YO`
wXQTˬĊTr.9%t<ԾK|.8@s%*DCy)%8JS+8%5D(
7K8(h{:Dz
`uT;ZY;'Of-P~TZrKMj(5@Fě@Rקd2
F@M޳y _x5U1uF
Q<(J9FT&'r+z;LKm1U	'	#eY[n]Wke*9r|abQk<Cu*cҜN2L/ӡpȘ2%>
s}]áh4ܻ7V%>gbhIm̺CW;p`KI o/SܧyX)^	-o\Ɓ[6bugI(
GQ8mvc;Ix`Im}}{`VLIfޞAy<ǖTV¦f)l펚^Z@ߑ.&4kK[2Eoe$;q;eJfr2Uld*&CdlM;$@m\/)d()d.C\nL8J-˦=$TfInd~
{Lu];h	h#v
nvqr%\sA}-G܉wtcr9e8wٽow/-Tv0K~HejÐ'yݽL"Ýx6`G)4n5'({+CI&{TeMʓZ=,[3ێ|)g hxcD,sR=tُg	SB(cb@-fO1}B<`	ʋV%KK~6c^0We=^R~Ҟ9Y~,V֖>pk:دq7ԅ	I+5mJb^aq{5	x^fC֋lw͔թ"%{I{h|G/Rl۵5*{KK
t"C}q۬[n3}bd!2dc-9}g'ʔ8Pus%S_TgG3Ͷݩ2rLY32g0lRIu^",|;esߗ<Ǧ_cT4O?e\.c"/'‘;.jƩ|
2/I%N哹m6r-(R^J*&WY^RF"?AAS4t	 h;rG>CDžPK*0$FmfaӨfYruIjd;(PM(e*nT+J4l-.!e"uu/CՈq6/Ykr2%ֹ-Ʒ3@7%3Ʌ9Pyp~%U<	|
4I=9K!>M:+E|̣)ͽ*Ѻ`݁>
Msd?/gH
gi<úKT4cDbK٥^R5.{I-&C
6hl/۠/kkS)HFIDeŽoH%HF_ף7_K mç!mF77d6V*:krKꐵ;]^2iE(K4kA9n%iAHڑq͕240`ʏкu?H`,ij=ΟytF؏3^2^_AyI=/W^JqFea)Rqn89 ez
?F<=pKQc!.EN:%6
wAO$o\U1
0n3=3;nO!Kt8;,YɋcGPo/Y|}1}%K4j6h	WbLBEFZ8u$0`vf[y],Wu"Ng"S8"/7CqKNCӴӹ
R$\
*MIn$t
%^Ҁt5;IJƳ(Ӛws^eֺٙ.J̬Ŭ̶d-2Q%K02{*fh΃鹀2yYb\}Em	9K5RR62MpM$b\howmX֠f@˘'_D,gzB5[%%^sGmsŎ)w@VX9]j\eFIN,LX_A\Z<K7-buEkRg]mUt];
Ut0\֫eq<ma7B{J1 yp#Wb%/1gng| yM8WIyEq@Ha.>="-.򒦘mժ@s2/YW‘	][%^ǔnUhSW"̲^3\Uhr6g>lIщoyAKEU|K|%f@u
DzfOJr;dM̶ZU|G/Y`XnAV۵5q?~M%X;54fcUqTC##vc^S_[`INTcQ5u8eA2[P,cSPGGxpPOVc4/gqRvj$9 ~]4\o	į%Wrq³x`Mj#pL]EN~3Cyx5%dDǃa$=q=RqN~OCowBHK3ŋПJz{B"XO{/.k]ơ0\:1vK|(A	i_,~_G_UJ<	D	xK$5:*<7CnlPn
TNn(>g*z@Ng)&= `tWMʛ<,J&nP=%belS29=d6(޳NoʋOx2^pTqNv4$led+9[[S(}-2eAz^Q)r..B[to"75ݰTf.pqT9
,xšhW8ԩ*!I(
,=%!9hϚ:2W竊O/R2?oS[YLIw{a1I	!MSAUY&o)lmj+'B[	}zJ
Fz95X١LK(2:ťU֫JRV$y\ƈV9iV"6%#btkeʙJևJ*GV?(m\Uv*];x6ݭx?آJHU`#*滱J?Niؐ܍
iY2,HI$˓ZDv5n4j^13ؚd'X(k\;I	(]ؙ(藵vy5୛(qhl,F9#g>

i@D5'am	#ӢMrdu֓zJ6N
C=PIgȒۤlNƻP
CHҬk9D**!dYYєĕXݮeb
dnV=adՈ|4nUYE[VJ;IP#F;
&34q3mkclޖ[fxTBEȎCS#Kl1}aԘ蘾
&_קꀅz|'%v@|H%%Hcr,)pBH9QooTq-'{%1rU:S^q5L=J,bAk1Tr=NV&N:?dѓA0L~x_ӑÈq{?:oX?aaFF?M1?Ob4):1򂩻&K1}0h5bz)iOH{o}(-/ǂ]շmQ{FToQ-QM<uhl#=}h?QBH4JBDbQ1L[ln36ʉ*#ب[Ce%`c =#
Qblll6ƈm=鈭llf6ވ[
b=Jl[VVgm^zlc[ؖMѱ}f!=iFl8Dl+[SZl	|ŵ&=r#8vn@XҦ6MbEV[Xma4@6=G۔gsX i;=#.[`@`{G
VvMl؀}@&eqεu~z\F\q]2J\t\wKmq]b#(q-q	F\q4J\
:Ͷr#&[Q&:mLv[X"CJ]u킅Ă,X𵀶M8,R7cXSl?'bI#@&l?@57T@;~D~HWcQM7^q1`/xd+(B~kbIw3. klKn/o2rW/|b=D[Q90kc,RYFS>2YTrC'1ߓ9.AN#9l,˗kXbN_'S$@_O1 NBnWAI1Q>&e1?;ADq?:At	PjA
 Mߐ7պ#Υ-xsY0,[fER<]|9X36FRerKr,GA˸t9Ctfك/J+3I!PhcVc*]08S܊aVSykBsWeD~d\AP:eP*Xm1[kkZQQUYWj)XePDUTUUwe%Q;:tXgb_'9ܨIX*
Ӈ
-EtìR(DH^ey{݈}O}>^8qff=L
_&9wWY>/k
Ձc\لcb`8HƁ:,ΟS
y].Evm JWFWz‹/?BƐGD=RC#
}9!A';|$$g! )|{<?Ga7q}
174C.203@83^;X'-Y&BaFJIL126R}/XCX].\bqU<h(ͮTj2#J159:簛'1Q2A_;2ﺑ,O}'I'HA⪀>q#=ZZ>H+eɅ<I+ׂs$5)cKoD{z򶌓%$X$3	 p Vdi'P40A'KW^!lfɲ;Ov\~\y
r>c]Q~+R+ap#鯊bkWH Q"7<`^S0}3ýRNm0IL[	߄&T3d//6Sr:6x)ǖ`7IL|)2LLyk`Zro@0}&N`Z~%`"LPYW,tS%&Q
]mO[l5)[ҽHA<,ב,.~Nwz#hȮ8z
z
hQh,vGĢ+=R^ޟ!P/0: eYVOEiYbx~d1;YYtYV_Y&1_-|_}&=1_BjOE[x{Zo5(*YYHJ߿DCId76]+Ї'7W;\p)'S8 cOLMIsIi^[D)7B>Q>3ї(^$}'cOL;i)V4OTZr(3yzeR{ם[?'\ŋKtVh@q	^yݢ?(ҟ!ėo:9$VbA.T24ӥdJ0Q5/j+7XMNӄgƍsQ>nӆvLEa:Emv(
*Qd0'^hƗXz/Yd)'͍)]ıqݮKNcO1,Gq5YxI81W#]`KN +>\(^\*_!5VW\erŒ+Үw
%VW|>+7\(^(+[
1W|SJ+:W4X]q}RWܗw\(^-ۤbؒvDqt!*ߓ#51%טFA:İAa2L
Ӭ]Ɇ%&~hdU̒Jy]޿ nMY@g	wT_*g>qL	k8t0L2QiNRy/+mƥҸmJ%[-&M,%!s^2fʸg|BfF-3ao2(cOR	&h>"}Ig]ZU9H5FƑ~bBTU(tQkQ0
+
+*+]ZH`qovgwczxEIM=d1Gm{TU)#mD}r4v4ԥ\\SGbׯ)Wr?l#Y@a
z,?u6e>]I]ly?۔ZF2Mi6e6emVؔ);s>ie}gcelMmʮ){lı<=g刾b-culN>ieKxr,cQ].]$]ˮg_}EmvkV(`?a???ewcMm3.beI/s,>OFd(Fvkx_cF֙<oeuYdg}Y+,n_7df#nYYd=3zFmd=oeFl*O2$ۊB<1Yz۩f[LQ-f&*Ͳ]m'u%.]׻ܦ"ޗޗ6nwݩ׻\==ic^2EɈee%ʴx4l$^D/ے+ft%.goP7@j!BzB}RDB6dw2jwn=B9W@
>g!bh'D	B~>`r{SOpEylP7#w,}CL$.0[P}P@	%{<oP4C:'E.ŭ+(N)x{
W?(Zxec7)ܥŧD((>=jçړh1\0gD{
>=kc@S::E{
>t=1OitskCgH<>ũ=Mj=Hod^/^灏kπS<37|4B{yl|хZ
|Ձ|*|
2$|?6|~"\S|\PK*:PKnLargonaut/internal/Macros$.class\	`T>NLd("!#A.I@@Pdq2bZՊKm.lkv.k{ߛ7of$ur߻s=s/SD4S|F}P$Gẖ@g<׈<u@d}ݲ΄Fq:5F{b)fr5v	yh/⟮QiA
5r2Uo;@".ɺ**_/Wd/ߛ?1PdstS% 
{覾Fj4Dotxx+{3FԣF'bnM4yn4Vov1uXnX/jt
<-4:H>2Mmdןzig:iMbrYz0M`;HX,O(.SF~bZp+­xST&on=ң'Iws^,,\t~fpx0haYtxQ_S~<ߙ]kpY0OL`}ڃ9X]`jKI+IX85H0싅2А#Ӳ0.A0-U`b12sY5ƓFKllQ3Si΢p˘WntqHv&h	ǜ4'jiP,]TS=gLR9]1gesvj@%ŽFF=lk鈆%q7E}>os6"c}$Sث:lF5jsYZ3GSa"cO.!CKK5U RT3dG˔~:|DtVZK.3:\d?U]3WU~14iU̬D
:)vW{~rMƋF«oG0tKuhGxZc?91CjwۛsZș7ֲ֬l2Tmû"ܮz*Dsի>J:ICX냉p \"G:7uD5FjkbM19SlZde@#Dy$0o;N=˖]MO>,#!M.P
@ˡ MC0&CF%Bu>$_Rң:rocMq9Ac=
@Ld-	f;LXA󮭕47Cr_41;j"И.+xvmx(Vœp<+2yBۏQ(7=M_j"Ve.=8
CW]ΦX):L[v⦷h 393
bp_}fDESWM.zb=i+i1eLKUrTc\n*}Iב[f`as MߤVf,ckz@	)(!>.}O}XG<'d:sb(~䢉cdB4~9.fjKDlAlTeC´bx\m6[
d&f,wa4g,G, vO2ʓ.ȟ0a]<M+1~ޢ8b_%vK4Z)o<FRD)T~g"f&`ᢹ@yIo4R	]V0ǯqiCEC~0]ed7Sy#3TsOWp%[AV1H6j$0'h'-1}lj^OtR>	k\
lK<[|1DV4	0S
]2!)<	El=S[շx"XW&h!O6Ӽ4b̧tn'iΐݝrշqk+UgHϝ&vϐf~{Utyy6S]?C<n?TNBDŽ&biE0	s`I6;1BA0*+
-kLX憐ÈvBS}j8b=(L5*hqYL[] -B́p4V
nnv'nzHWHw4k
X󜀂^+qb ~w8HiLyx,F9j^qr
'9mtt8,*NXn G6	KrBkN@8Jȱtr;8XQˆ'z*o4mo~\`g9iNx#o= "Mao126VV^		/I;D]ߵ`d;tSHJtbL͹T -[{/o\<[9Vx5*f8߼?Sude|_F2LCiB1Bjͷm>2GC¡rbiwHm	mŴw25lUyitk|EMS6?+#HLҩ<ԡGxYG_$	͏n
苴i|r}Xu5AQ?͟EDݤ^'>dWͥ9)>7#rf>C֙6Iqϊ?!E}ӂ|/t<ؗ!>P?U,۝k9ʜk/Lˇs_]T/!ͺ:d̋VEܛZ`MŤOLM.3^ɾe~?%wnҗ@?sR>xn
5Ez?o+2%iML8$#e﫱IM
ZY%7L@$3Ap'}zf_a:]%`w~K?m3Uv1
oPC.ෑdcjj2hA1̽p|QdVOp\Q\K\4KhC;YLc,
2',GR1rGHЯ	/SyFBY&(ryA"M>-F1t.a[82W;Fw2emGr$zHo"'-m|7~b|VXh&焅4cbܧPB)) 6hb61QL۴ʍ%MLɣCZSA]
*pWY(܄y.Nn3'x \T]@oLQrD枓y]+{6&αnpKnw.[Sb>VKJі^nH%b1z]%^3bJuE3zx: st\1T@G[
#DŅQŊ%iAy`bn b*~5S}Q5^*P#A~ID\*n&Ux)ǫmWm@bRA=2fI<_^6zDDz(Dۂntk %8']?NqGnUw+~JYoU7$,/
šY;4 vQD\cv[$qMnP8:eq"~}tr9(ZoB#D_<М(nIa?tj2s0˻
~gaXߧClC4?ţ)]oD&fkpvVE=hZ◷ar"˅D<.>y*W7Pms:v|YnIMYhb#F+Y
n!SOb?08=8"x\<
CmT'faU,IEs(l퓷m2˪Yǭع6ސkzsm`JI97b<(wzO9-'-g~j)=e[/\w7E"72h"a,H7BbUCIrIwr4V/a<9T uYS;}zxFDjzTQOg5vgKx.Q5Yُϡ,hA#>>F{l9}0N{)iI(4@OR(sxa:C|!ЗhYzNI_S[keiIFCQM-o7JjIAu_VXIcq몘Q9Eu%6u}\EO5kwdh
j;|Z'pu5׬q=k2jKY)AKo(iI>WzLg%yt@S<>	4|̬߯5Wq#/b[x!J䬦Oy^d,*Wf"@kr8rћȏ&7lB"f^ʰ29Mm0+'\PCAiOO;+$:B2t)KE$_ˎpALr|EDEP߱R|/,c/dЕe[(_nRN_4~~#k׏P>~#ɿn6??KWeY텀ϥ^SsL_eUe=D52<>OnjM}8q'Uð8&eiT]5>mvxQNT:( ^Z/^:,mN61OnzT$DBDzS43,Ы"1@y-qTUF#=
X-
R0'x	C_|G$5Fԇh,]I'x=;d~^JK4Yic&8hh"\FT#ыyF;51;H](q/˂.R^Ĺ Kp
_KcqPv$.8?XhbI(G dl*:j+2TP&z(™.T@
sZ屆<,E8n+i8y%V*3Wy!`pu8
8>m&^k6_+.拫TbFoc%
יdcƈ	q	0Afg0
``<Ty5d&%pK^-%DGe?~w|PFK1rrGV)Asꐠ9h@3n~قAiJ*7aI=݌ic$fl㌼=h1w,o5X*RuULWQvSe
+o{)l)v֩M0&M	C	{0]faUsj971T;z,Jdq!O.yyܥx;vk0>yNZݛe|sSU2ﾼwnvAOX,	xmg)0-)>
R3*J1F_n5()>Ӳ*&|jgJ VW+,*|p~1^c3|i#u%M"xăR$5QmPFAHܯsPLح<تĨ^n'm)6*ZnTX.s)ZnK<([myZn<䦛#NlcjJެR;Pn)J}Z(AWO#x=r#_νEk::&ŬŨ11fz(:斳!5G's;^QX߽9;rނ:
L
xw3늦>Vz޶49XeӺm=%%F\lzp#goM,]ӭG$qt,1L94Y1
fGWF/:WNg)H5XCR\4åCzŃ
-dn1H`8l))-RӾKM7RH2ޏR@bk
dV5_X燸%0-!KJ2\=8d47'4{C2=K?11*^u
b}cħ<;1B2t ɸiC,õ%]E~ɘ~2]'EhBH<V0h҇B({ceʯ*5BExZbtW\	ZÜ;=['Ws[kx[`Jx`5AN	J\9ҡfbqcR5:nftO$ٌ$	K+Haڔ 9oV՛apeCȤ1zF%[!zDUeKY:½tfsuV
o%M+ >E\Qz,եv(SJ}#{x
X83qBQ8ZoE6\yW7
ncw5A?I(\ڂ%!wo]zl!ѓx4rr1zdΰ"xr@Dpt*
&ِN
ݯφ
FN{0E344ƞB=]Ǽ;VtE&Mtި:퍷\GJN+r`)аjTeYS5X8:=07j|aDch]w5NHbyŝKe}PeN\Jv6z/%E}R5uRpe8\/=E2&F*0!-nM9X-
wH~<1b(T\iث!YVi0Vc]^>;qp98;421#{֔ꕺnVqP42˝e	i9yax`20:HS{&_?vvq|c_yVg)ndU#nؚx9uUg_Xb\ZQ~M۰:ZrަKD5AȫUeT}TCڊQ80hT@ȫW]Iq`i٣ITf.w}|I*
ҢNuYP+yp+{$:J*-wAׅg_ǭ5Э;jHZ
Ů}SXhEaj/+HgJ0<;]8m/9;Um)QTEGZ7#k6#Eꩭo'=΅Db$n2Cp|NݣQ\Mh
=ִ`1bD_y"fRPv֑}`%0i%x>na|GwXoTZ|)-"v-PJ4m:E).jLbc1>*#Zz",~:77~+5&}wب/>42*):.M,ƃ}bih~r_5QRvRݹiO~J[g/7$u^bя~k!kݞ~}?_h4J}CgZ3ͭ\VA&(ݢGQ:TgWS%#MȕeiH\`؈%mNjkA`|H{L$5
3$FBC_MDAX*ɡPdkp:B\\XЈ^.r34Ѭrg
u_ИדᄯY]-eZ
JlC'1 qʠ\]	;k{T#Tl*1 |x(Jb0bw鄽)A6;&ů֓p7[Pת'd+oꡁqjK$FzE_fFB"璱X:-5v	n AKbb|SeP%l!(5	p/Iqz%wklЃ7$P$h2tBw@/3{/d9fo'`1Bȟ.]_'Y<p^!Vooyhk|3
cLi%.|K_|[O֤p9Gp7]DɕNFvsM5d.؉P#h\ܞNfpvR]VLqY5o0npbkmr
&dtϵ	=%Xj
n;
ޜf*G>='#}~ԗx)Ys8#G>fa8)6VO`c[rnei8
Sk&d]Ҝ~OֿmvHdfI[,~J\dKq]K
Uq5ӏS̬?dͦ&,.%db5koOçO#Cq2ӈӷ.I8rs<ĈH%MyIݻ9farg֟`z~sS
G/!Yp}}133䇴;^_%\I#ִfڣ?i7+'|	ldd^zN!f][iǟRiiMt߃3 DYw]7!G'|E`
gv{ _nK'

Q79SH;ҘyNN|DiP%|ɵpjs
	bGybDW%ppИ(iݝ3
w	?C;k[ndVl/۩RɣP	(oGOx#fCu<Ҥc̳eQ;o򪡷i+j!&pE0TU;۱Iv4qш*zQ_DNVgDh`a'6l6]x3.]K·k}ҖiicOX4"	s?2 )wGƵh2\38a7BM_2-MkF|49M6
2ʷ
/DGq	c˝C{MK?jQtfYc܉sNEz$>&+/lr|*|
R$3ć$}NB U:s
nϖk{gѷSCZޡ?pS:EҜrglEo@d[Vq2fE3G\c	}2o>֋h޲)¡yp<OgRm[w1jaLYdl`[44l9ݭzn_g*]j+LK"z*}G
4Bٞ=+~ݧHDX9	n:c29CfyDXRBB#$?4޺v[moWMHOC'8L
B'twнLׂLoBrGrhGfDnD0 OaXY32cl00K$LpOgJ~1H^*.0hQ?3tWH3
iHyYm
,1HWW]3H*xO	p a \
K\rplcWOuZaג);&'<8t
ofkyz~`k0
6лjS޼]?u^ygZ-vq;KP

<}`NyY|`y~lM&x-ϭOW/W(
ȉ!6#|i?C-re3.+(djKs<)F=	ڞA+Xqwϰ|w=l
/yPUuk2v(K#$F-n <^5{WN|g!x+HofkEP#I<W
ۋu_W#Mi8x+Ty?^q{}G; R%EL`s
;YEv{:
cfT"Q)'5(%S1<Li2*ybIbv}֢9P°+&%:6~9W2.y/5UA&cF;pGReYΎ" G+00Y_gp!:K)wN;jfeƒƝrO*B3+8u2M$L^cjIuxDJ*]jVe&(Me*u\ ~M>a2B`F(R0f4C8\҅}oZ'}zrKJdzřUeЪBzd|	l6;q]>3g87)G- _B=iMܛN++TM RHP.^[ua=!g`^pv'f5
5'wA +kXp#F&w]8֕o_S%BWHX)ή0Ua0Lz@
5vڌ_|:j?kg1IX_lxVgMMu^hj7Za3ںgʳxf0tsKF>aAi#[|8آy>&h;{}~?ݥ^/Ǿ`}*|;=cOyR{*?"sg!"r,I%;(@+%|s7#p!%?8؎+
Ѐ)|?rPK>$9PKnLargonaut/JsonParser$.class\	`T>%Y!$(J.H 2$/00(ֶV[j.Ki:Ah-ڪźץUZ[߹,/$??潹{=|gw?@D'jӰP|[,J%.OĢkBu3wMۦ޺hO}ݦ$C	NSȣ9la*0n*at&ЂL5/-e(lc}+Gϋ44cBюmvT4]g*13UJ#SAlmxxLǢnĚ
iH^_&Ջ׵,-NknbϴfצƮnbtp4d7%rљs-5G5Y]h2eL]KnGsm-BC2iIr)&uwɃZE\/fs9ؚ2eZd,#auR[Ee&o
s9Lܜl:
"Z-&8BeGBP$ecNu:6
6v\ T3W`f:Gմi\j	um:CX7me*EYmLeyo~]m4m,҉"pZ:Q;u)|9׆hg*ZTW;!:t[;bp԰N;)"oPuS-fV#E&(D97Cmi*`:;ί]	Pre[I0>Bh}'b9~cƍB MNhm 9]ig(Yi$mp3#hP1w}2ʍK+]`I#PËtaЕI	nAjcKnrckMWB\Jzz~iDnT]e$֦m]mh&YOund1>M_M,LnW>n˓Ly遬kGpF[S`g,hz:ѷtGZDnxxSiv&v$ 4T/:hfꅇ"֋uCDZ
x'?{!o̫d.
ǡp 7sj5Nx(Hj3O`ġg;67}]:=#7 /XZjrPJ#!z\Ͱ#1^qPG2bA|ca)UXsWP tӋPyf٩^"?:gzmW{sm[/sfKt^~eE}e(پ}I<CNۼT5Go
z;jN2	1ĀT,Ft4`>1LnOdoGa9<֎K:id-ҧT;x!YA*Rѿ}N~`;tZCfm!d++=s:Y2>&0T-(`O`}չd9\?+eÍuu^tVwo4)vYwN^nڌhqB?Q݌.JIҐH=̌+?"_1ʆ-Y=aT+%!i*pGk3rG8~8[1̡޷$_˔Uy|.*[.?)~ZIЍaիChP-%Pk]S(,,Br`{Z:粌Y+:?/|\F,0r5zhi+r
Pwl`&I~W>?sۏExuΐ݉)w'F굀ίoDQiٱ9Jm,=[:}2/ G?,ŏh4R:Lf
rk~5>vIswu҉_,5Ce䑝¬`7_&0;J*ܯcUjPFkU1=/3 D]kCEp*[j]a3͐u¸wX)Vv
-Jq!RL&O}jjT6AbmV7|n~|fI#b)ułR0i`_e`GT4sOѬk'kh6[ܚGk=Kjõ<]hZ|u4m9t)z$R[RA*xokxTiJ.AC
ocQtZʐ\궾MB]L$Y<::$7}Љ@ƪAz?Hcz9lRzvcM6о[~!_\նAlK`XV_W0$nN[Q;#mmjk
cͥf\|TXצ7GF|Q$Hx7U5G#pbj!N>R"iX[ZkoFhJb?ػ՗r&
{irC҉5i: 564ovoXKBzJi虦+{(K~eb*jԪX_CmqyEhؗx*Z\7W	ZޓtS\:a*?&c\Os,	L!QqHM&'Vj	bt&Mv ysz4jDi]A,:?ncAVԻzHd0mE	8xuFB{:>g	:jgTfj죯ƒk[o,w͑e}'w_{<UwSE&(n,7Hͯ+]A&> 4ݞoPQ$*8[Jb۶p.{'zG@0Dh-1^J4z+1uaƇ	֭G@=5u%ڧ嶻Z+ՖPZx	O*mK-SjAYH)dWNӾ\+[,JMYdYhELEիT+N&U8fj]gj3S{JQwvEpKuy/A1\3MCL(Mz\\2j7UZ3QC^I4Oh<ހ!zi75F_CGi\4Mn,kҋe=)^M24F!{>m$~SG*c/'f}r3
R(OdO_Dxzd3gRbнBt'mňvM!$S@2%@jnRXSCD^gwsVGu#pʮnYݐ܇p=>&YC+ΏZAXw@ZZ 7?|2r]ys
sK-_V1\ҟwef7[F2zd{ٗ@\t?רD96? @@tl4hd#,`."*`7σU
G@?(`nY8_O;1r-[#{yB]8k#4qV&)63~WK?O:	泺Yub\pEq]i\J[~}/O5p"4׉<4φ}^*yiMqYXsX[4#uamVS{-o;gdCIꃽ5
qVIUIͤrysPSU歍۶;;qn.rGD&%Lr=\Dij_XCX!C	ZQ%Y( xi,_Ÿ$J36,kVnԗrBmD9`r(]AWӕt+PO
+r>典/toy;ҍ|!4}L7*,w&#0X-UXtY
Ù|SrM\╙q3o$;e4*4fxSA$Vzv:ܓ`o?'y?WXHI*4 McQ=&vt)uK|fmfmfbfs>3C
wB
媩r^2`| &߿oK7WIue~\
ystog^4 m@Vۀ.{i+38	_3r-so6q3	%[hf(WGosd@0Y0)44ZAӕ"%/tli1"E^,y64Gir%)nܐUUrs&(bgT#f#<o}gҨ^~Na
meWIU2#nH9TW)ڼHi6O-^ʿT2eޛ%q`,|S!8ΥC=xNY\Xvm|/%g1K_i*fYX*ڧR@ek`%b'~R
X/
ѵ:r
ڴ16]?KiD}Ge_iqYGԮI>vail9`2*C
3! 6L=C:wgkiLbM=K{ڿN{`EGCڣ,dbOFdY}Vl8|@goelu&Ò
HK
Nk8,d1ѥwϝ+/{=O"!is>۷467mro#tj!l7[H(fAr"J(XXj
sJ\,c#ALJjEI@-R[XvPo^QAvH|bmIY7߯RF-ԽA1dqJLNl{۞3۸ơmiÓvC'[ئjNnZ`15jW+ʵmC
}0?J"
(G"Z;=L,ɒ,`~Xr/$,(qXrc,{.,,?1pKMl$Gl/r]D%'/,(,G~,X.
f9g)XK	&Tu-/PKTtc	JPKnLargonaut/CursorOpLast.class}mSXM&(j}bke*!EANsHj\әB/|C
!5L{͟}
Q761^dž%n7cڥR'V88\\)ms٨F4}yUQmlvt%}6QU/'JADq'J	fj%{?oda) Jn/Z ^›t?U@!)1zd08WIl?-q%\]xA)҃iLe ՎW1~p&O%00:\*e3='ܠ`TTn*~uY-
#ܥ ^%I轨9aS~<%
2bu]+%%%!- O8^rݜ uK#)it甁vzAQD^-/eO7Ϋp(OO)˳[8AD/3l/;>ܪ7%=KQN2C8[iH\m*NܻBUѡFR1
yki4ArX&ewTԄn-$j=uK]?9U>HoӫQ&Nר0KRFקIٳ709zFdSBsSV>}@ZvA m%8̇A_>gIeKdCa;ATVlm;aP7rs((%W[vAV/
ٝ#CeF>ͽ}pd/oƭJsTb&3b?mG1҉wwlԒz<\UҘRG15YJiy6B-'|@T,dSAV6طI?8(Ѓi3tŗ]XzUX
buH$}ێحylU4BW!ׁ	#+ge'
Wkt{۩d`<&PZV18I+E'uHcS˝Sfݳ+_C2\ӝm79_ϹsVխ+`9ԓNr"ONgˮيs
ۺ;+lR4ŊgM\K}WOUHf\ǰ
SSSF.Hb;xs2ci n Uo!v|ШTaPgݍ9Ӱw%16)D9qB/8\w-b1@tLXv8YR:'dT\Tq(b,Y]9\ehŒ*8Qn]cAJz^|
O
e7UqLn5sM`@#A>X_ȵOFܮQ"WG`Y=OAꥒ!v8
4luf,Y<'Jթg耏5L	fxS(VOV*H!NTǑw:kHd9|ڲiK	ƈC?U
}uځI]U)z8OfcRE}|i]#H/&%0Nvt{CH{=YJzuEKgtV'1tGGbb}hz'q7Ocz(ѪH5FJ1zaa0}4DkP'\9!v~`DSp38¥9F;!Uv[|~2=lԦ_lxB1*E";}lՖ0zjQnxAw'K9B={~ƛ@S3oAYpii4Q8DDWpsS	`,CE$7PKղ:
PKnLargonaut/JBool$.classUkOA=S
ˮVT[P
V(؂Hߦe2CC~MHWxg}Dٻwνܻ۟}0vn)}/4TicXϖS/=gGf
eEoEQr"{2Bkdt\(m`l[H
QE,zވ!Dt`2P<)#_|;6|vpD/WDx@F͑IsBA0b=9zjES˜ܤҬ3$e
h$O<"DBLF/#ζ4yDVP
6EZ_eyiU0L?cD?BqQ
0Dbq}>)pa#^s):}ZyH2/oT_/m}#';r|(?GDxY;UkQpK2Ex.;gRxA 
-sۦ_^}:;GyQCD7թW+mMw$J#p+ظE8alwQx'.QpA*
X\	 }誌9ٵe-ǟ`.=%y~طϧ:L ]8^"#>{Sp*PG(vCTko5ԚXV<nCz^96SJ?K,a,0;q&gV![RK-y5{x])s]3pr pkAˬ.Wf`KY;j#b|L}+l%eM]-$v"yB.=?C~pXF]p~$c,,Jת&ɆBΖqߟ-UG6šӱP%=Y†->FRK[5DTZl[udPm۶(dvqx{ yqzb>}<~j׿}sqWަ6[ʖn7}SPUC=)B'8j|Y ߏk~DxZqD`&E aEKPKoGPKnLargonaut/EncodeJsonKey.classURFߕ|2
X19lᘏ@mB#;&q!|vadQ-'M&Ӿ@&L;Cu2&'foWw_0*BPk-Sk٩ydOq"ėLD{N5ڨGvv
.0gGک0RjOR
vJmgmMn5tc7Dgq̹٦W+}OۇQĪ\̟W'bsyETG(ئ2Yo(nE}f4Y+Gyeiu,tb~d"/Z`0!iQYEXYn/j*ˬaE,O$ t=W=x온a S+C9էpxu`m$τB{"z80FeS0
eeS7(K^Mc1E
ˢ^d1Yme[Oˏ~Eųs=V1JB1|yti5mԯ1*[(s'3?y7㲻UP8Yes2Vw˚Y:L\ȇ7OEqo*v‘:9YՃP.j^^%$2٘yO7QOE^x2_=[؋|wo^$TYH22KZ2xqT7J,KA߶YHa((lL>wynCwAeY~{\u0tj<
Lg?k^BȁSjD6sP"pہAm*'HE
	Q,nhg9e!ߕׄbI0!p0p|l00	Sx`~!Q#<	Չ0ӵu8Wn>ٯ򎚽	;w}e~a?(7(n.?%?8MnɢPUO_2L}uVr&"\mG{7ZIZm{F iZ^,İh,{Q@KiqZjB+Ib7PsȨhCKa=^l-]nE.:l34r4
!
}RDۃ@L9Ӟc;NR`kD[;4WϾ=)t
z:qAz^GB^:ph
`ۣZyd"4#ޞ&9G's8/i*PK<	PKnLargonaut/CArray.class8SYz׭aCX`68,N1B
F<0l;YN6$a{l/Ie+U)UST&k	|%Tw_pCkv2iXyy	X39Db~3	ٛgmnɝY(14~XD	X$BD֠撞vCTZj?\n&&'H!&T,nL(dKXEVcdvczXpD
WH(+3s<|)LONDJ> S7v,tҢ2"ҐA$SM0l!&BjX_kpԈIf]{o)=ztg9ݘ׈-:q';H7ݨI#bÜEi7I'}:
$!OcfHk(DUb*iDg)OUR(+5x^IToC5PMc7ǖ']5KEcTT+C\,{Dki*FۅiԯGFK
<.u,91D֬'PGI/#s7ܹбJekeina}TAxiQ)(N5Dj˨wbL_}wC֖uf=
dϲhf.;֣qEÅj6Cs2I'ižP\?O191QXsXgo,i">OH}t}h' Bpd7$ul(h'\tcUOr#3rlNd6;%d݌6{Tՠitf1!+x͙E`݋GAϚ?$PĂ!|N NѩcA3ɆFH0)
|PSC"=k
%]w.F-D;3LsQ!PD
abb
5TLswH["lInvFeEA˜ڮ
adG)Rv	;K,@	q=&yi*NDɘֻhʗu0Oi]IϋAcXbl^Iv:cI֙jGk֑}5	METød,&0|U=!zQS^o~3e62cr(.^@!S'bFHbDh?Qoά:7#s(y#"a\X(l{p?,	1IiV\7G&_A?>V}&ƽur~V\]ﯭMG
	6fo!qۈtoiD&@	sw(:a/O@/?[=~$3d*U,=k`./ p2Ϥƹ+(32b;DsX,lqB p@m^@48qgn2@W(0Fnz'>-~}5oE=o1
W\(Y	uVO6"CGD㔭b.n*.h*
p'zHd(in:@D-qj8 <-vjAW+
}Vh$w=0{fzg`1E1ikA'\BB|7^9C$F!IGĽ<p`	x^REtVfGL'Wh
p{a@
W!^!^T
U.WLU#idz(q-dί2.'.,8_B2e
D2V~^QFF4B3^aO<XĭJ
'cS
_:ߏ$/rh&a?E

f!WৰÛsO8);__Ęm'^c3r/~u&Bn5uno؉kN	:!m#OoVxorLw8k߮?2yI2sfb;{o糗_1O9cWYt'b8mKYo.V\sX/>;&B1re7)Q~Mu9)Uۙbn˚Jr[R{]MHfg3i,e}
{Xz;-?@@y^q{
oD:AAH=BS3h_	w$lȊL
x8QS_&=4۔~T^-Vkٜp>F$Ω gy b+O#!o8+G=ķ>S|d!o_[[V4H.G#s
8Aw{'x)_nea/Ѱ3Fl}Wc5Gg06&C}Ӝ]C}اF5G]:tۇ^m*H#pWL-Gq<B	ր5P0]spK˞1Co|j
o3/}p* (8>c$e% z9悍~&9-f?}zFzAa,C
91LGK'	d\苵fv~w^xċ^3{{`xwK㝉VU3njkoWUj
j*Վev߫A4؀Ͳe&G*YU/IG[(k)橰tpO
n|}#=Gp;ڸˎ@{ZkzgP>NZA~'ɹKXoɨ;dY^PθC(+x~͢m֌b}D]
Uf?y'Hʉ|_/'T_@V=8`G/jɾ*q5ۉiF($wqͷq RnGާ.?Mz
W{4Fz>vӶvҟNSIj{e:z]Ol$
	9Gxgl;ff7%.rc{аj.f{lO3@9?PK

PKnL$argonaut/EncodeJsonKey$$anon$2.classT[OANK*( ]wڐhRPeq!ۭ	Je<;,`ffϞrΙx2aVMD;(Tu'_z-G(eD(UQjzPU_Wu"a7B0v.تO&"4|}H(&Vjclc6!p	#]8BUCqD!yv~`c0n{6V a!=_Z໪ɠ{yl#b&]0i&!!KF!sb|i6aDHV\aH N-PĽ*̾#|Wzr;\VpWQ$UsJm[n˫]>+kes6L0w;F	OsFnu9 ؛JIdZiSy\Цjh`'q/a^Έ,Op#bxiIFM,MC`	2QEԙgV?\t$2s3)#%6:/)|EpOtHwsܟ}铑fO~Oyxf`dz:xh®ʿ?PK]ٖvOPKnL.argonaut/internal/Macros$$typecreator2$1.classWkwU7M;mh-%Ab)E	T҂7m̄IiQïҺZr$Ŵi_{>{Ι_^ -ǖU?cھrmier:^*WTUwB`W̸jRE?#+ffV5+-X`)#@eUSZC5f/W,']2K̨C90ѤRוW1b86Wq~&ю8K-F*U
ll@}UfQc竕M,tWL/Zj?x1
l\f9wP	:@w	쌶5oRadఀQXj,)R5+72-Zeb	Lu],yrj-	l2pLjtT}e"xKvNuBYC.^+	īݦ8Yh54;ClcX`Ӹ8F"g(tK3vxvzz
#ZsړW
;<:`3(@6Uy.b\3\bwLOŰjFaIdf\ز$ZϾ9v;&zMzQ-"_CKx\`L|M"sWOeXkHnt:n'\URz
,l-0v=@|L[(ݦNDN/Ww0WhЖ[
r_)%b=rUMdJ4$uU4a'(#p*ʫa\'K'[oNITJ5ݯGWUTU`jmR۔!@ &z"mȴMX7uZ=גxcefr\ܢܴjJGޜ_u9M^৛i8&2)S,+Dy3}r<6!s|ܶtE뮼1n[<ݸ=dm
V0r2,yHRZgg0~\qL=ŭx/;hELhpW 'T-A??㳗⸉9s]!g0C sMs8E%ʨ͍GxE}sc}+>˭g@}"F+]ԩ{_V<Ao7Bw[=a;ǝwqq/8qo?1~pPKr4PKnLargonaut/Cursors.class5NMK@}6I[hICAQꩭ(h&lҭqFymof޼~~EXcEKV`Xe^u;2&`y0	͕尌Y;%(xiK.X(RTU3}*^5vvX7.~:f˥=7{5O6αK!yf?=O
d
fyUBdWRW>2ޗ2WL\ē#?f`ª,Q/heZ
PKI@PKnLargonaut/CursorOpRightAt.classWYSX>Wm"	fK6,mH'`,16-'"EN;U-?+US35LMW2S5fާ's$ۤҡ
ݫsww++܅r^1+z9U\Wd؁4[/(NJ4:h%+dIk2VVJ06Լ&ղ2M͜J0Aagd%4)2kӕllj/x~eg%aynq6H'#ab9MTIbi7w;Nηs)U aa=>JC9ĥ׋#ǫ"|4pr89''Dhrk>BlR\$v;4^gb^ЉaI~7WF%&7LrDFiN$}Q SR~g'n, b@q2J$'-It(dk[nZۤ8niZt
,Pr,yړ2bA/Q>thId;QΏ,ǭvDζ{8Zzk)AcbUIjwR9j;pѯȑ@nO	 W"Q)+*3dzFOyœeI^XXO>I>	wF%uŕ~8N=EމO{˸smq	a@G.=sOΏuG2lksd/x-7>v|OwսtPabα'G:ac9tk;-?}kh:gۮ qvQ(䦺k-TU\?DȖfSôD(&]ohg}cRKWJR9G
VcEFɝ.z%rwL8ycP.saq٤|O95d7ε7o=nʺ Y[1lѿk/p0*<}PXWpᒳ;f]d0v$uPM:T-U265U]kI=#dK.rl,ߤ)+RI5vϻ']=Z5EOu"Ы嬲G{ZǖZQi!0۬v
hx\ױzvtygxoƙW/P@I?@G	̿ǠMam
A;9UPg
*]Ph?O2>3!܁A+o$5}
]8##3P{TtlȜyQG&د5i*)'UMTg#|Sנcjk̋13;O0y?C$gxãd\s!xlAl+vHprakD/ScݪwZ/7bjzdņԥ7ΨTY$έc͘9>9Ym8C?fhe
{f-Ƒ}a̘y|Dַa߁nx7`gC?tQ;Me87!J}؁9دlk&COV~IM?>~N׊xDp;/x;WWK©l`TCCbFd`UVWc%թZJiMϲPK*EoL	PKnLargonaut/JNull$.class}UNA.AmUڊr)IMD
P,%!D__ggҰMw朙swO1݊csOf{cv:vaC͆%nqb2s%˴M9NWrL@@t¶딽\tźYchO|g,nW25
AE5haV~k]}@w-%lБ*[X%IxZCJ.ڂ'֧.Wؖ}[͸--rj+dpȬ9`KQ.CS}62Ѝ-AR1ܥIDrd(
3^UI3Ѕ7R\:6wɱ,:d/Sz.ZV/O+v&0! d"DO£KP/^Y1E82
^^U򃔌X񕁈ȈWQ],^iyokMeN
]%H
ufb٬\z.-\Ue6$Xv<$fM}Nz$
CWA{0B#ty|ŝCяSNifxL !w|𒀑D?xfX+
n3{Μ9?~~
3^MW5O1V|)r#(CokYgH<)?z^*3:`vmd7N48KNǚ͝YgoF=k)"_AHQC޳]_M|z"lW<[^]		a$1l
03°s-$m;HӑtmFMW~it^oJH2{?g_~v6(hDOwǣ
uZ9ԇt}iu"anO(aaKSabboC鈒BBI%W̳{Zwa:Rnl5;fq(X(adKn${+eI-ۘw"v^9ƻ
薔JT
t;r
=떽ͧCހX$-kn;y`ΒfTi󑲦2]cQp
ev"(oە^W\Y
n
skY
#
%m(jU(m2$P
̎m/m>+bEaLv˖6Iu9rq["yCQwI')= NN(Q΁`iQǎhaKNZ4ShhF3[&w_ƇZ1Um|\YG'};_J@Cȕo8=jiz7.Y =]4?*a*ܶPPwI{#sEQA%,EB_d/QP`IUnYTo
S)0ۆb}N8R\YO|\Tym4\wɞvTrg͒]$k7.f|eu2;S76ͅ4bP yLˡ޸jʛN;wx:iJ\aiLrq( /zdij8-g(ɕ9zwP%e!Es[CžQН610p_w>~
r&;:ǶL)l8sxж`pTREoX!(#=r
Z^gϗ.8yQD)42p)7B6BW,Rɯy;-l^D
yyx5xfʂaИPC3j}8>S<5=EA<6=kZtp>2E#mũCX(2M\KŔie(ޚ1K
0`׬k|PlN'["Sb]&k4ԒEBVXvN
MJ]F=5"IHw!gwMD(2Kos6kvhz;7Oc3j}0z^GѮHBf.f-N&Pc9M_oOv_76INR$LD'eÒzVfC'
ԬaF&J7u'L36
0#va=4tC3"#lSͶp	M1Hړ?el6&v3gY(Ls&AebMѳJN2xPTD4`Yv'hJ1nMc}JfOЦCۉ0|+̻ΧD/éDκ
9n';\ !>9BJ8tBvs)+'<*<JE&WQfyK
1V|fnY,
LNxi
֚$8r)u9ff\~x
[d׹ZIָ! ebih3JT}04ݮNfIWSSNVX0-60F2&-F+9)0BQC1Tʚ50
>J1d1)T?AU,hSv$|1$}ȟ3K___^○UJ,}J_|CCQ%!UJy5&i0[
CRHg|b2I'avIJ6'Xq	>nxYy7옏nR_9NSPɠq";b15&u߆Hs1evPWc DK
vfϪ|6f3:h25ICV,iYZ<d8-Y ~zC<n=xtGttϳ΍~XN~f\s6V[cY5gȄjYL+tM0ՈCjxEp^h5B/v悚K02k9kl
V	|nsIdT:&kOfU
I[bcuƪ81
m.k'=IY&^jyT@2F8M$QLŵJk>o*&Is:z4Se&;u԰(whF=m
qdQyx{w8Ҽ˧L*	u%*vN|)˰˷\xltQ_4=x;׻x6&'^;[h.6^	Ś.pF]}
 [:	|6i3DJw:T}!fkdōd+x	5p:H*VtnɾRNeYx	ڬg(#Z]U(>:q'	#Fʁ
|j\nPi0܉$/%I2N
Ucm_^†rD<c?\~_/:%/τpWůQpoVbʌdO
2o[6^]}yf3Fg2En1A6S{mIypfUhHa߃"VitJe%Q75fę^eV_j
V#f[Ěu	p^L]L&

뱒:WL%-)C؄z0v4V2e!~#.G"ф$|@]09gWdN9ɿ"`OЂ7M"	E$I$9T6̡´d
}7sظF#iTb$m6J2(jaTА&\v
^z>]sgFJ63Uj!/eA}PدA!g#Fپ2)A\؀A˰kuawg@	۠0a/A+WzE݋з&lIie4Ji 5GWXd)
6M+0h`\'
T_5Ȁjm r!
S[I_}ҟYU`^^EJ
4Q*}fzT12x{H-^qjozޒHaJIVsv=r7~4%~-

2&SWX9͟.%+s-̟zLXD\Xz$\)]+,&Gd2<r1Юú.gW+N)s8MeaID#ź%ECc98ȏ^:Q~N)gSr"ҷX^.ϐ旽C	S6n#;6b6S
ՅQ8N4	/4H'6J
($'I=o5?]͇V9L<楺`f?lS`!20D#|Rp/]CZSzs/i?j}Y\F[пE%-E*[V{ӶlK<:hu\B%hy
2"
=%X[/UʠatӰHVP
۱.U*l*Tc	tآ%܉P܃LJFQJ"*7I]^="z=تSذ"jFvW#|<.lz}>5纆hkv,be^.-;s{nRa1ۙv3lhr
_ߙ6)`f(7?/{E?fTW=siSD.2E荴}l˘:	J9˘$aEGmFߡcST^chVt6kɒTحJyVf*$
eHuEd+a(KdkHʼnfOD9ί֋3әę8Ϯg.Hg;ZFG;K΁FGKPH:Jp#Vfĺ@15ĺ.Fۈu>7T.
X;>aa%p%|Dc`	_`77Ƿ鑅Bp	ߩuĈ2"k	/q#A2.wV?A)"~Z
drѭA(	'BP`04	`0{	qh0 ,p;L	w\8+	="Ax͈OӍ
^O\Oe?ЧWN@~”AU:YB;K}9@}p=ӾlB	F_ѓF{-.E{N{>=R+K=@R$-_K0{~K2,%HGܦ8wdivY@e(dYA_e?dY^odbOMkUZFRřsYetÑMr<#l1Ѭ*y9"xR8Ӊ8\dJ+{@o
,c%DŽ|W1[bBſ }wܝj#]T~cϯ8Zܡ%n`u1.}jv+PK\PKnL(argonaut/EncodeJsonNumber$$anon$14.class}[o@fbI[JhC4jU[J%(T

)wIr֒/]BHg~خ^0ٝO[
<802ݗԫ(0oH4ionY{Cy$]_vt7(,D;}/9*+,5Z`X:KԹF@ڼyjI?Q3ymmtCE}M,h`QOt$.l*`
u.F	pe86JXX(wrmTqw)5=/C-Gz@yiV$8x'C9U
w}FIȴ=S{: f	8}cT(Rl&-}1"ؤ*,~ez=r_@1>qS}yװd+F

&gfR^]/3ԯp)եi{gD'OsjhgxKxL_MsL:KZ٘PKPKnL'argonaut/EncodeJsonNumber$$anon$6.classTRA=٬@"^	(+^J	Z>	cXjB`GYF3=׷wJr3dKm/p
.,,i`.?e۬7wE+bu݃TQ>+e\J@!p||^p[nACa|?z73LK,B\YJRnA[W^
{R
`:ry3G9f#aukc)8nI,'ܧO'DXҿ+$9iPK9Ń{PKnL#argonaut/CursorOpDeleteLefts$.classT]OG=lo4	ml8@M)ɒ@ڷ̢eg#SxhU#5k~J@ߪ;;w=sΙ;~O&jɐGTu-jbW2`cR*8 0ε<gZ=٥F^fH}Kvn0}?mc锇1|H^Bq-${λ! 5Ƀ6̉~&ZRӇaPFL!r/By#<:l#Ի+0X{&"C1P7_^x"##Cg|ITN ̋Lx"τޓ
mH|3XfDx2R
Է;Zӫ!]+Q
w%CF0OSti?!K4Ee qk;ۇ~0KIIJCΟ0dFV=l1M+M$c1B+B؆8;>9Ń3|hFJp@k	2
t0H}F=)⺲]=94[?soifHC8,},M/{1±f9%oJ\ixmkw?67}P~uHbfN<3I[k"l?2*fPKX4CPKnL"argonaut/StringWraps$$anon$1.classmn@ɑqS)"	(wAH)R@Rm]\ x(M^ԖLtd#抌Lz󁇔iД7q@\Ck.=zS[ԧ:3C#E˳`4
VdowBWnH`(~F}C4F˼E};ApF*p">gF*tڕ&{D\SY%lD-~x˯p??u9	ig@E~F=+܎`7oshvKp̐H^YY"?cc;W9%p734ur6ճ;;67u?Qޏz$hXq$H뭵vm{nal3PKQCPKnLargonaut/JsonDecimal.class8\}N @rؖa;8`r^֭k,{8#uٖpI%YݺutMu^z¿$X^'>	x	BI-%J61NՅHL[NFy5%`O/(Ql*.dD	5Q*Pڮ 4)u1.d:&Dd)d)AQhzÌ
Le=.̇Z$yR{/+@4 W4:ZAq5Eh>
ysemG
_50"/M\tI1tu4_V7K|%AUH~nOzxdg5.#M#N)x	x[m[~(8
=z$
-r{]WF-KuU3XXY/E'L\^i缲Ћh*5݂4-יys##su񀿙ɒwZwigjT
VaeޅlCcuf/Us]j0!rZ-%3]].I	zxs{hvE)C+\`;wK{~._Qʱ-h΅鮥Tdɐ\hm1ϵ.\~+|y[GZ9
?0:#N;*zkFf:~" qToqd_MbF(Jzg&ʽ(3wW๻z{]v\^=.Äxv>71Nȏ^t'.ohYon_!,
6EOEwc5
s#~:%ϩF4:c2#cCtȬ7;7Կڣup8HR]+5qބ~E<"x.D+Us])j]mh.7Y@\ښyťC0kqzJ8r	\u;NѢNeNv\Y,wH7	=%
tf'gĠi/_\.Sb G٧3qY"Dx)^79)i~PğBPKS{~NLm%w4*vE$+8QiEAO]C=N;^d1gzޕ!q-DPeŘY<`ͪTc/)_Ȥ"%:G21%|l\I&WU>L2Iĉ!;7PI4Ghf2A5TA
ʡJ:ېŽSpOal{]V'8BېD6nhC/٠^B_HĒjz۳S@"2ˑ4Bea>k>x1f9۳m2FߋP$%E-rxfCtak~ƃ^+:-Vbw)O0ϨWaG΍N3#_!@&)Xp.$w7Ri$;J<m#bAz"A0gÉYؽ-BQ$=E#KXݞi)+dcIĈqH;\`3c3H\Qd_$3'LbÏm$b9'yFƙo3hJL aَ&,i$"Ȗc'R16|LfQoTp)#7#eF4dJ6%
Bl&eZX(Ў	b%\*`"|mԷ	uoಒݬ_P9
!@,jg^NW`?e`?Ф]HDJ;#qUcŘ5EQFT/%{3h/j0Og?HM"4v+<?KuN#T&u|ܜbVy~v_f]6x\0{꯿Fx[ӹ>%%(/7	Td߆'0jDI06{։߄oy}z:?S5*!¿RճH<3.f1+¿"tܩ#7t-p8UIo$^v`Cdw4 4'ٴVwB@V4HQOH]kEٴ
%Ϣu[0޹
oX;1"XBRrr\]R2Tͤ)9hJR[ e㌠-oBz9¼4)U;Aq^NdJz<˃v^H$R4M҅.bꢒfX':gSbvQkAm?bu 4&Jh~
Wd3gl<3BM+2QJJ5d!ۮ[.1w5H;@HN	HwEjR
.Az('}wȆPh,(ȶ،hB;^ Xdg>S,EGr"|VI)1"Y߷3-vOw\u;/NVh]pTE$aB3>;]mGݜ"n%G]*5Cީ:Ȧ&k-aiiߐaP\omYUu.[BE`WELPqC	kD܀&J- F1ĨeȤ7"T[PO"$G-fVt!̏u}'܀9xPr}>l>
G^|'>?̯Or<<׷L[-acKZ2olYo#!Y-$[ĥ߂!YXG;3ɦ".bVVv[˶JC\24B\z}e[n7!)_{/}%2߀|W!WסtLx}ry~sβsu"󳲓$|8
g ,up:LSDGlPls%*JrZ&7˲Cɱ
F܂7Ce_[dMяl10kr/N9ނB2	uˡE.zYâU5,^cUiS.CTSu3?Lb=EAQpcV'g^hJZ9~phJVQ&po5jExX2<(A_(yQëF8bGX
T)Crm/5<|6S_"/z^]T!2~7	_M_d:w|7$S% ߆G@@fxr&틴MkگpcBG./f6ʷ1icI9pcݻՙs՚y4
"
pj1Ȯmg"
u
rD5G~7)6(kb;%N(wFh[a{6fc( .ԺE~gbCbSQU7
dS9ێk*4p\6L >`"I`}XY
LU(Zv9l[m'uTBTl(bQG?Уٮ;A:7fCn&TJtz	N/1۴.!@
zU}k3MoC2h%z?A>
7ppZxZkٌQY06}NfC[[CBsysk᳚$.!))qx7j8ȾHQfge
ϵSlXΙaE-%\bCV
i!h5i2N1g,lקkm"PPKM$PKnL!argonaut/DecodeJson$$anon$4.classwEǿӴM.-(VP#-}PJZZ)Ri/ɶݺ݄ͦP|=VGy3&MvvGf|Ν3ǟ1ռLKeډ\ƌFU`&PͅsKZ'CCègr)PРf%XlR͔gC]2MC
Z0t--GES5VeIIYCȊgr+?>r-錖6YC%p4&6hA3ۋ:	!v7ɶ.+IԌ3HCh~ڸ@?]|'[
!CE={pǏVw龽ЊoI=ҳG߅]2Q%>쑡{{OA^(2SA	r?D?(Gj%zq:>)>"У8VD3DpwϾ5Lٻ%v(Y\^DcILعi Yeg0#'I<)E.QO? Bӻ.{B@#89:s8!n
	g:'ŴIǒmne%:C_rzT&G_;^_xEkE\^+x񒋞_^^?(-f*Z |cg_gг7[zk/&|G|(D=Câ)
H(b]@,tEPKUPKnL%argonaut/CursorOpDeleteGoField$.classUiOQ=o2L)P".l"tQ
ne)LcGytN
@"?xt646w;wr9w?0nY&/9ɥ]BZ];#*)vtH.n眕st˜C4:n27NͧYaпmCPV**z.z-"/Lg܍cP62#C
pٜ36fZ
BA8VyPhv
,7E//X#.CQ*nz70~dz&<-7
R#J}`h){-S"
1f*<40%)jIz!Eol1`cBT6[whZCHPԺIp5*Ѓܞg	2Ƚ/Y;BXx~nC{F7z)-l^ξe=;%S:<Z%;'VtTV&ƈUsעv=Q=KLOJ!]YQϡؽ@r#2uDFny\0E9PjJUHW@~=J,@gу091@dՏ^H7]IOX-$\&Pf)5䳻xb7YR;jjsf@&l:S@uajA&d%u=YB9]XA
`{9mϙ	{9ND PP~m"(Jo漛L (&{Sd¨}\	X"+a9;r2jmjT*P2_JqgiV&$ xп|XF7!Nho0
9yP]EacR&T8ҫ}g#n)H洷{ݛYds3<'8(kjrd:[z1^Ѿ*(頕E̕W"1s/Ev!jOzf^s06v.QQYv1Tj8voՈ)bZLLĶRf!QvFB1v:_#>!5杭B/&RσU'py]7yT@,rs\:_
+!Q[Әo&J-ssݗ#M*
9Dcuͩg(KܹQl'yӋaNu4'*4jԑ0\B%R
qD(VXTRQ'|1ް2ڨvdlUVhxusXZRFcl»$Y;E;k65*#llj.(uN1*D}l(>vjW~a(@J0#Oq]3nDr0mm?tۑHq4BB:J5Kw3*w`MjLBlMl%,M7"6D qXX_F
:!Ia#̉fRxLXdC
%"keŒadBZ`03NiE<#Ǟу$%Ti;y59WWNU,Uy}!	얚c>
`CX<2yF69łA
ly̼c˘1N:+OlǓMg*4(|5*O*cR\_+	df	IƋ|9qliv|>O.,Kq'wwА!@7𽅟߇EK/䲉ViZf9@
!_+_`ݏخ‡q/RqLqDQņ4I G0~+{F:{tqmS's^ќ«,@'0Ýb2Dl-?@ACf~Z@5-DSqL>7NSݑ>oSĶNvCcӷTNҰ]j#7lhN=hKH:Ui8iY5Qsk:la.f"@)z_el=x24[6mYGͿ\`t[~(D?9r(Wv0_g0+:t|Vͪ9ywx>WK#⒚MpE~%Rt~{]3}'p{h_^ιS7nNCx:ڗz|
>.MSJ%<,
m49pp)J*ΩR/h*6q˴Jބ_3Xc_=p[l*D38T>4
m_PއYZP QETYG>_}ݝ/bmWu«0	h536W3@+==8#8s95pfQ#2
>Ï?Ʈ/Z^^Ga psB݇+.+w>}HL@	wG
]}>\bBye*\޳bpnts`VI
$)+qguLxCXV`o!h}lji}|rPWjӓ^xS<(|}(4o83(_׃'xCϰˁpJgIpOm75c+ߟD>)Fw1>ljkwޅQGg^z㦷R=X/4f|KVŹgPKPKnLargonaut/JArray.classW[S>=4b@w@\Ʋ!0HX .-쌤Fkl? >8NeryI7sf$n6U{N;ז?\85dBA>w!P%,(9{P'25	%cͷu@RA&
Hlvd1B(qDm5JlT!=Q؛^)bk\\$l- S;eA}7r2Nqїc%K>x898>%zrR"&$vGs4GU0ƫpBnd=ܔmIN]!CILS#IAQh(#rrjd]'RRfٕ0xnHYTn/׃i[yt*b}ӴiLֿn#ROr*T%^/Xz,yP65c|;h[JS6<]I;|wI~+ԱfLz6iG^s`]Ohi^,~+m;Q|HSf
]Ӝ[ FI=OVBqoKka߳(Xa,ǜ{jEeٽq˹%K_쳟_跻^kȺX_\w0a!y%uJF[DɊX#Vg(	7o7{5!h/⎝_nHzd׶D[M3AKpI{SK5N⢶,aٸ3-N;iݭm%fg9/p
?FXu+G"'b<8KNf{(i]U#$nagkEkB${mtk6WReQڻaEQnwn'І8:꘢8FH0/YyMM޵{Bi9mkc~M)蓶&<!U̯.dyrMl`~~Ӽr^QCubasYn;^l9	lbydyPs!O@B-?3ѢgQQӓs=LTSUY&I\0FیCH@KϨj^sxðG4/N_<\ziAϖ2*^+*^MHHZA`(R8a_Q
?GT%hu2-@sײJXُ%-[e+_0Er4C)~J8~5C9P
ZoZìf}դ pzXtA69aMwG0W~?qC)ȆToKeu_faU*+ĠJv-pLkނv	xw+ύ\znB\u@ľ,&`Bd*5ܭj8?Q7;w`Q^Ren̞_:jƌYp
l,"7=~uoRi0as
avo{@[hA~^sG
8loF/b44ufL^GhDZl`pNJ`	'0U[>>IZ)YSG*@KޮOVaz,D#fG5
od`5+OZ$+V-YeaUt*PK/	PKnLargonaut/CJson.classW[S^[Ҷ12p$2p
=s
m& "LH~@'3vLL//LLgtIz[{˷.(#]SF,X5Z\<\p%*/[XY=BJXu#!}"	%0K>Zd>9LMnK'i.$'M)EVVVkeq²\K.$泉~e[JsMKNG{'$LVC)h;߻̳}jϚi";@JacVh}_>",Ҟ$Si6]9g92:ݽgXbC,<&7_Rk`bk0\ɫ$O H>N3х,3;ܾ.Săr"Y 'A[UUM)O/	<-9Sa%^jCX6<$ ֙	ND\LݟqPMdaLaժS+uGN
@C6QƱ3󚛖'2sgL{۔FRՒ?wܒJ^]Qp[)쩺i^V^YV-+
CɽYQ}k>6rnrN/Zo*(kn(c~J;E)PRz	,"7)Zq,];~m3p
g8RRƏ
5%[X7pKڕR)I_*_*x5b8Jtw`-B?X¿\!uL30'm̙$e౵4cx`pNf-Ny73z`j?4N>k}+g31cj;q;~j90,U
U@%W0縀D`AUZ8NdA8Ylf+dPKZPKnL!argonaut/DecodeJson$$anon$5.classwEƿ֙I D1:d$D!C`I HbpA3I:tzƞ+z_|x{^	Ǔ5U[Uv?s&c(ys@Me\ƈF%0m#sʂҩ+L95exIL${z{VP1CB
_#Rta"	Ug5kX:b1s(o,-ci#2C[ahTWsh*7%41ˇHXM
1Tn5.J6g-8ܟ7s-턚b):13p(Bx
`f5tV
P'9ƥҁJ.e܍{?Dj.C{bZWcJ O34{:h,Q;
ݝmnuNFy=8[fX%W(Lrlj<`׳kZPt-Xr`ut(3D8@?rBqILv&i:b~Kǒb}2ae.9g7wў^N =J"Wqq1,Gӹ@8>k?Յqϗi /62Q6U Peu*M%.ubJqOqT;ISutoOE%ݤD4W2C8UJ`{b+UHPHpc$yuBEeJx⩤캲6S6lyOV,gqU8/k#Ժ@Il%<˰5kwwX^iTK%E?Y,u	Ь^:N1OʸPi|IhxGm"<-#BO*LҮh~~J5ȸ6c(VޤvW1՚ͤꧥ tWn>^ܑu}>A	?agυ
[+'܆+y/`{lv׊[B2fAd2ĸ>{_
yrz#oiz _gk77o)\[Ja>׮N%@e
^9
㙼Ob+TV6ו\N^=HjzJm_bo.tْ-bF\V"U \Nl\đ`'z:qԉω (=@Oa=)><^/iczVυU$]''OS+zO)г+AQ0P`_:3-6:︁x)#tv;?6Ϧ7Ŏb&&J붉JM\«MMtF|`(Ļ+uj|-54|VmXfZj"~M0Hlu!R
oEfIYO}DJ{TDNq`PK7cϊPPKnLargonaut/EncodeJson.class=	Xי!acNi01dd	pζݦwv{tdWf{J4MvnMnM6H4=fk#".}^Lx'HHAG[YX=uCg	p$HJ!tᾅ	-/)7Ս='!'E@(2y+ed-ƣӇ/l?w|'X
ЀDYj]l1lGQ㌺ʚVpX\oz_J\sxK.;q4^Wkm͋
G:\d[NQ=Y&Z6~qzdqnEoB}>ثeޓ};n>nbZZ^d)pP=c-#CoheB0V36OGbGP?#maa.\Y1!9=/fuc<ݱӤ/nX9/4vV:Ґɻ@?;.kV9"B{Rp1
v컩߫w/58p&Ck/)vWYgu](9Tw‘eCK=C\]agSyKꃴ'vtPlMgJ8uzGGk-5:ku1r\ABƩKYzn{ӎ*yP:k[;Upv[6.s^΋̃SN83U|1BZ~}eK/c8(8,69`O@3ފS5X
^kf+'uvG鰘~FGQe+/Twb_5Sg:m-[㓕~Y(gǶq\}c
3f
0q[*fqGR^w[=}
{8eЕ^1L\̧;+KCt~Ϗ|.ٛ}:#_pTӍ^׶RcYQ"ܳO42M
LztT{C?;pdu6dh(ʳt9rQP0!؎׋&z̚=dغ-:)Z|cfpLAJ{S貸dl ;tqy|z_6d2ђgu9%:8Q:S^Բx_s1vKʳ9*P~xx0_ܺ
R{ưF4vɺS{SGl0~9̧~YyR~+zn}hw|魎FݴUVvaWeP׍*@702XZɵ;u,ŧ=玛+2O7f]`a`?{KyRU9Lǒ)PtɣУWأ)骗;^䪦~ n^I^E}%G|v}ƽE%ܛ46FבS߰5kz꼉My:xAR'q9@`LB1ȡ(V9xKo3+w0z3y}7cwGɃ
h|@~0+Џ0&38o&)O0F3yD>@1)=@?@Ѷ(I]?/Ѳ/(/.Ѱ/)//Ѯ*-Ѭ'חh7-Ѩූhwwh
?XsnLh2O0]{4~_Ӳ`#c^Q-[ghl
ZlSickaL=O~I#5EJ748
i-8ߓ?8_8MlkqHD^.sY\]ػw+5&H=#aG.{wM;Rg<2>co׊ܓ	Y=a䙫=j}EȞ`	7#l.m
y|جf;yE!ػ
T4O͒]Z'd	{iN–)mbtIHi:xVӯʩ~!؋>rnCSS
*5!U+$rbI}Tj]H*{9A&
T@#rueւ9YgTfG5CةCۃ.cp/4nmhFfNE.$qQ&	i}Q Y?;5L
}rjQ8\8$uK2u(~;݈x}TI~`\Y$b[EiT*s^&\E)(v]P.҈p%ܡ2pKy2y'Jd^LRIJrU^Ly\ݥLHǢoay¾N}=R;FeM;JkRLH63YI1ss@ZTүo2Y[}ƅ餗)Oi)P	lPiIF1;wIST0Mx=~8+Ε	ruZ?̀TF.JP+TE)^'}~qv|RHE#|)Y^u"$h _B>1򨁎@K[&Ԣt)L6 	)fH_~N|"O&r?͓z<\+m@e~H#1vFf엦F6{QºRqfoxPwM y:Bz#/:L9 'f|>n	~ūe6ŸJJi`nWP=2J'`5KJE(}2TҤC
%FN'q׿O
o܄mtglgBWa\Z.L̮t(7>$v$
7
/
hX@`Pر((Q`#Q`((>qrycgt:v;n]K.f;{6%кui}KR[KEZ/Zg/J4hMGk1bb6HVHhW4M	t*1ъ]+$wpb
WujʌYm\%Pk	,
M+ex^œ@[`eDؙѫ&gy[$ï|s[2kgLϫ,c\mʧ\RY%3)VR*_FE)1vFQ1MT,.!٤t5nRwu3ދ-ޚ
#ag&a^1/Kr*ƘJ/⇡%ՆHw}&n&EL,o,ݜOnMˈ^-S,73nbfܨqW06츩1ʮ&Ն7:f$a=`4Yߘ9brd9A/tM509-V	FNܐcx]JE]̨>E5b9~%+fbĥq P
E"\bu!W;.ڒ^xNMӣM)-)1ZiK9H0w`˭E熨T1W$uWy36$_NVLZӞEQqdcj}1)+ִ)m`*1RL*QYt^_ٌ>_j>sنK4d@PJ҈3RghA77]*bj-JnAwPu֛V[^[	Tږ.C+UV*Q*	mTA+pՒ[K
IuUoVwU-/Y5\UzZ3kymWM&iY!UQ-Ruܗy>aB?p_xiJEmF(~b}0|łVw{)+M@~tm;jOd[߆2+a֦l+xKvL	^[_Ts.qT7"R*%Qb;츯:Dp@LC/7\(-].F-jh:a)0	~$.|jdbZ:oI-&ȾJKZẗ>q/d	ڽ^$zd/%:>ȌOq3ν441=^Qѣ&>rw(v(V;+g]Ө^z4	xQn=nowJ+Q+3#ʸ2j
KE+N>-)'wyqW"~
u=;X˺DҭᏘݖvՕZy&s/NSb}9H~87 g@L#E߄^GuŅ	JNp-x"UG^CI!#i	oBr>R3!]5{k4A/.IB%d9E|@&
A!	;]nap`T(ʅ
Rao|r膳px-#9$Gm8
ql!؁NpƱu88q(QGJU8q؋>u8qp4hıG8qhцÎ C8Oޠ$^
\e'{5浍O@["Jhҽ CeOjC&AU{#)?J!6êe)ER~L2RER>J0KYI*'YJ[$c
OR#KIUb)GR~N,eS$T)<I%Uʯ͑_UW%IUoTw-)UoHRKy0iUb)J~ҎVq ?dmG?"?^EOYm]4ncgς6IPoVd=7skVCG6Ȟ'j׈Q	h bukuM_߬wVir
^1%-Fjaʍ$Գ,C7h
/`?K};zQ15{,q'dW;6!cq[4û܌F3bӓ̨aIٌ7Tx`7\(u5<ԼEPOe<&ul؂,>u|LanY+"ٖdaO~%-MH4<{%=϶u/ՂAV`rHC(mFz)˶t,ypBz9ߍ	i=^KL(D]i@Zӫl1l?n?mʕʵ/GљrB8Fx荄3¯`(]g%]MG~6+E'ƧPWqiPG81r>u|[CIx>çq<}Þ2XU} 
_'2F6!plđVG
hfhu(L%iRhPPK~Yd@ 1PKnL!argonaut/CursorOpDownField$.classUiOQ=q7[*KjUԦ6~|S3dUm"IM~ka\
HSyssϹ~`)~n/U0HiB+`"]rǭak9_-ک5ӘN18glK3ۋ&n4k.ChQϚ.r°'8eckmz-0XS7%fh"7fhL: c"ګj7gj"չz1}#!jݖы~fh&"@D]ݶRJ~O14!ha1oxbȖj]T@=Yۅ>b	Ħ`pYS?z$6J>b9fV`>n4^q-,Zͳ7x
Q3ځEߗC"ϘE++R(#
z3ĺo
;LӘ
ݡK,ωB$鮓(vܴ#HW9!YH,i{F[cՕo4[6I[ZVڏ|#ӻޡ.kdQcKQ큒k%'->*oBOcq_ˊB
GXL8]?!og*
MpY1=_J
qNnTaT:斓c.fi[䜨[cYzLQͭ]1ͺ{6Aձq{4Nkr:,}9iߊ}7]?I?
3D]PܬUF:GpBGU)LC:^iquء\{r\FW9hvac\%iq%}
_܀愴qfuS
ڮȑIa~E(;-@wN5>jWMLȭkCw@
SӇښ]R(ecf^'Լc(0Qe~(2l:ZJFC,jl[I\?Dz=2?q,5QPgݹ@!JZPFpZ>@{{@Ǒ[V{Jƹg+Z[UVRUJy](f)>z"lIȱg[8R8r?C!kVf52׀7ħed1B{VkEqTUBFyM8xgw8ނ?xpΟOts0
JB\KnX8p̦pej$܍J
<7xox8vBK6P,HU@l
d/+)X/_Nǣq{`643MHwfI>l_ lJ?ܒ&ڱ;`NJn_](+/
Q&
	|~س[xB>	Tyg-,N!#_NOY8/p7VU-dNTbov1*ߡ	d!S.yTv-ee]v
,PK8US	PKnL(argonaut/EncodeJsonNumber$$anon$12.classU[SE=3J&ȚWH4and7D/2[sI_,Mx,Ole }9M(pYZ$,GZՓκJRiUv݂yOSYiKYYZY/wtYGQ;|X>jaPY(LԒm)p9X&ճgruKi*K8ЊvaWVVU'tDRP9b6FqB`$-$F~i%|#xnxתs8pAT@񳒿*bxۡ;ٲpiQ]]gpv|
|ñna6)ZfQb?'@q綡=Zu9p0׫▃ `D|b'ncYk;J%#Cl{:}rɢ)KӶj
0iTlӋ4biQv{{l*'!4BF=E?2?Ci$lTl7YR~8ߖQ=0:5զAfoZ3yQ
;[xW8//w0&^+̬1xsan_>OɾxWܥ

O\/`lCMU4rb!16v4n񰡶Dm>O5}Mf3}r9
ga>Ma>{<Ş0<Rx$`Zi3,`PKe\XPKnL.argonaut/internal/Macros$$typecreator1$1.classWkwU7M;m(K m)
*)&PI*Lnd&LJ>_uյtr$Ŵi_{>_^ +iǖ5?gھrmi
pO2\%}4!-sՔ?'fnZ#u-
mPS`g,-]SZ#5┕1VZN6S%ɕ,i/9h`>:	9718:[u==xfЉ.ew8j6ָ/UM
+(kX/nX	2LCckժ[#V\lĒWla^b5lXD'kjI&m
h2#dtdmհ_`WH~hmOa(%
G&R3fYنjWolY
j՚8eS0]q#wIIf[@g6g)}(9y.i8ADx	/plr[*[*`@Lcİ:ϧ1A"Il9Kӹvvzz@d 0.\dVð9ViF2ØkzAi\*V+,<
iliȾ9v'yFإ:!pne8V`LJ˒ry.Ά,\0e̯f@7q7p+(P{Ue5E8KBw6dЃ.$[´.m(qYdPd'ew+ͷZGA
B~55uu%P6BEnКC%
ipNe[AR҇)r6(x75jyUkG-(X	YiJ:2HlIZ?h1dڦ?5
ڲ=3xRHcMwq]cLLM[]UJmti[5.~ahbrpxM
uҕEH\\C]4èGmr<"k|̶NEbc̶x1{`}/ژ}86|_? Nj+qjg-7^Xjoc)n?Żqf[(/`*A{?aͣ:o1tt-b;2ax᪟{sA	E%lgT=S&(S}+>mg𩐉:|*<@;]4{ݎCv8Cq٤_Ͽ 0qPKpPKnLargonaut/CursorOpLast$.classT]OA=.QE"*jIj 
P,;%xPL2FMvfgι;xǃy
aДAu›j0h"Αf{!:RJ{"Cz湾&CDŽ1pqC'ñ@Ú
Ēb8W5^(̩=F7CB-MZWs]iI\ lu)GhUCU]_oZ5\pQ_B_+0%[*HYyYh_by(.RUet9+Zt.#VzY+I,SFwyפwr09mYQ!CP9bp7qWE}6`8gJ(BYp!<*L{~ʚ^iYƉWg xhJoMD[i#	ݘ	%Q]=1JrpeQBeY_$:336|€Ga6$™aP]sIz٧$dHFr9-exL	AlOƠk.zK#M1LҘuA|Bok0u
7"'qVtd5;3puL,
9$3#ECސDu۰{fL5F]diɛ?ۈ0K1KQel?єOSH{(FcmcmL}FS  i+GnN450]d#ӌbFAPK%,j1PKnL'argonaut/EncodeJsonNumber$$anon$7.classuSNQ]^mA7j[`hRR؆r,C$s!~~{Bk_eY{Ϗ_a*V"
헪^ߑ~,V<o:'n5NnO6׷q@<@Ff K69*NuwTaUSEPRnj3pv	^BEy1a}]_!PLeRG*tvE͉%l:!k_c˸ma%MRn&2XvyWỢvl@)XP|\)F>͖|&|$O
VC)z"$O[
+
^/ x3 M)sVG#slTp@]g,{g<8C\(vvqH}Jݚ;hl!vo5Cqja}XcWp[p2C/Ostb`OR$!&ՌR1=>uc^6KR{:bhz7,S`ܥ35Tyԡ1
薤u7wEhCGazMZ^
&-x([Ɓ.yTCf]iz<Џ'WN"%dyY}+7ΌnJqG؞k]8{V5yQ8¦i:
6hI]/YS;E{Ӎ.ZՀdekU\ZA3G;)KQ]<"u(|\x񭢀<$'3]u=D1Q
38168̤Nל$z#:-dm䓶oʋ}jZNxqM$CSu.}.v@G±e ZNOD߉$4ub\7.$c
.s_\}ڲ3A]i65AaMyJKYpAesyXtf1c;Kq9x]1ߋ|ߝr;EGiagWo◕HbRnpqnAOyqH|(#'#DtiQE.!ƃGnCm -_ڲٜu."pJ	|0~xG83QmT L)L۸K]_]!uD\SptFViTYU#+Mf`S;-3}IC&F6VRߧeK;r4Ÿf!aD	{dyHERW:g><	<"6`vMgaRq%t%-s6ԞXoaNV--mH%*IiC_]2n$Z
EղiCۨe۶\i"+gj.H! s۫]=#4Ծ֔7.	pʅ|iWz=Ր($T.cp%j'4'8|`!ci%M DMM'#MxoZɅN@2?:	>~51vcNOIai2cx2V9ȏl`}
<m@l`*c^X{	$K72e_PK>PKnLargonaut/ACursor.class|\EgG4MM6ͻ&MjKn4m63iC$td7M􉈊
ORAD@
X(*(*QE'*;3sw{Mχ&{|3g<<$aEC:-07!Ptnh܆$\󣡩P޹yh_x.\
ې

{yѧ}h(0nHYqf,Z;HFHޥ.Yrmvis\uñ>5ˤ>
\s=\Y&Nf6KۃKu*ҢHذz@D{+qW슻R&A7'KJ{V߼з>~ZU$bZ3JeM8/W6e@DzdO+jV-*,AJOvIne^MUerVM9etQckJCurDjt8]$rOͩ,WHZ!w2Q=_{-LpøhD"nُw5wvH)[|,WHPv
,:T[0uPLd.0P2?%?vmxWI?qƇwxbŒgTUh>T:ٺ@T%4-å[q,X Ct7e]AO.jpqk@^WE;í?ʐ
iUq۶NYjN3mN۫s
RZ+dhoko?^qϜcy"mk8KDV
5箅:(ҬM(E8G>ߙ:nj{fw{
؍PHȇRw&?BddZa;wy'z6'}ԎnA؟L$h~OB=Z:D;]q*н0nxĨ4%)\"qz^Gsvt<tLFU6~AA30'ݱgO^
PKv(PrVÐ7Υzcn~AF9ՆiƎAdCTvtgaPF`ŗ}م}EUt9A//d<&ܙDs>d<	$t=^AmA-YIMW_E^ϲ*!i[Ҧ$LO\)SHQg2YlRYf8'}*׃8Pg_x։I(ȧxgjW0'S`ʅٸ؃l4PmSxOhƉ}lq |ꂆK qTʃ2(Angbiƣմyu)\7҆p=ۈ^6A
>jM4RZ3ذN\(ƫJЃxdN)
hN^z' '[LheBl/ex,[%$^:Um֝>H:z.q\zP&>t1k^j0]eVi)?A\6fRqNxP6x53c}ӡILW/wsx}2FbהQN
H /%-Zv^4Ғ@-k1!u1Zw{ZKӛO(]V2Z>^PsTD6m\/@38S/-ƹ2؃iy;̎ɦrJJiu]@ǶLi	hyoAo{Ѕ,spVLB{P)RL/[G Rg14#cj9374S
s^P*eDnvoݭOu
uA>s2T?1=kÚރj೟,"'gZ7
z_yݿAݿ{Pe6"E-_|jǃ*(qB|UgVNXgY	n+StWIFk%bumP7ÃhXM6b'OѴN;M\]${	{	{7FSA$9TM#p<5/*X-z="݉kyrOT\`q?&n%m}A֓r^kcT<!l[Hj@Z|ѱX|HiY?/[e<@Ϥ CSl'΅#KS]nhi:\$Nyaq;,尵i^M7]ѱ==X0qj4ϊB4b`#APf$vj+Oq^zb찓v^Apؑ2H$fn_$v =f.X؄toNtN,]:b>t="OCgc{$Sl
9Arx,P	w\lr"zs=7;q9iYCiAD*Yi%:val/ј\.x';q7Q:O}z\ϋmr⋹F&np1|{ċ5:q.0i3t{=40v%>͞u-\)&n'?Yr{n`7:\`­ϋAdҧ3ؽ\f'7uċK\M
pW͞7b &$1?䂧\3.	悟3Ag?\VD?1&N N*nmhr<.4;IZd#ED@3`JBDS$Y%.?0c^Ӌĵ/&:O'*/ھ܄MR 'b}u_Ji+*eB2ᔲ%Xn`M$tzlCӰ9/+l?ڠ6z.\Syc;ai'hwaz$:v;mĨ
ZLې-u-m!ٕg!H>}DgW4N𝷟ꃑ8FFcUb8lx2TDYQtA/9!, "Л\Hk@d~g܇ʪP=IP6Xpp5Ap/̴jY/ԐZ)?QUڴZj5TT[urЖ{Ʌh+u$i!<]FKh2&{X>KR =+ӷϭ;׻k8PgVW}!h>@G!
:(CIxVU/a#ښD[Mb1;Ao)zf	[_ȿIhE")
ֱEƎIЉ6V;vl~@7#4,$bq UR1
N_&}P^6;`^ODҕEͥt3&J#4?oExcKfO5i^HW@zUtMX%iP<%tOL}>xKhIAtˀW~7pzp	}5kBza!wtFH9&PY @_'U4 q݊~lthbހf78jFoFYW6"6
6t
ʆCDط^F%FN8(-a*f7ӋB؟Ϡ֞;(Sl?ibSlDwx=mcdcƺS.pTA%&cIpA.&kr:h$K?֟u|%X*a)sf
m>{
[(Maڤkn:նA!c`!a*	Q t	}$3E3ax('b1wsysLsc}S:w&i98Zc_?+Λ_'Ey}1Qi
{{ys?νUysoK?q{}6XDQ/z@]^B	)5<2=F	٪N#gHF#&u%>RV6CW|}BqSj[._˻Pq%X*a6'B"٪]L`ۢ$sȴSL皰?:sMLZ^ߠC,9ȰPw٪׭4kn#3=^-FI``d}?1~&
ǁ5kC|O$UKd܇U	7g9-zՏ 
TU&Qi
%k,tGdWaOZ{ѪOս`M(ò4rTtV
cBZǐW~eF^y	e{9~~y;hQG}z_E9,uO; `=m{Ⱥ,0=esnɂiPU$"S2Sz"KT013PtpĚƹ[$KBȔ1b
2dACϛ-"f'8/3g'8s*zxU
-2\>ɤ4ClXH:v>(S}ő<(<)@.2:\,rŗ,LX|)T9W9W8	S7꜀*hBD6ps3tf\os}߂Djͬ[
j'|+hBεf5re&8`!=fu\suTF%ry/LM}2:DM:~8	^K#}:Jo^gذ{$֨	N1c?~Ȁ}SA~aѻU=5KfޢٻW'$]L'ޖ73`M`o*1fIQۓھUˌ#Ӏ>w2;{O'w7&{=A{/N97Kb?o~$`?ϰcϘm	Imocd>~р=}_dػiaszȐL>!f#	#85_Kz!1q3$R`_gZ1I`q1{fIC	}a+)C}%GO1BΏ̜8&8?d9?5s~l|m_"UH{
nLn3W/=(="=&}G @odeD#
d
dlJIYh#ad1(FKv#Q<U@q@/>=x_^J$)$
dTE3Rj];LbnԒʋ
yD}1?1=
C@LdNИ01]`8tE<$bӥ,LatqqH`zڂ?gM`tZNNw0Y000=Qp2vg]`o٥;N]a75vWMr([b]Agk=~"do;KS֒|]`lz̮Ȳ{^!lQ"N}lvՔ]_f=.z	8;
)Eo>G㱗m/doK3vX@APKs'ePKnLargonaut/internal/Macros.classW[SF>+Y
0`0$q
!\Lhe|Id[qXr/Oϝ>K:=bIf{ݕsΞ]]xF_tMU3&#YP
k9RRd#R),<
ĴQ2݉TeDѶZdVU|TB$Ҧ@(d!'͘D1V=1ʼnxϿ
P\,'H1#D;t9EK,?#RY9Fɒc'w9ÌsjLU>
?=$m
ITN=kT;K%INJqw7㤆R@N;H"3.FdKu
Cuf22p-Ы^=$$3ĭLfz='>;Λ~N-H#=Pܭ<{
M$q	IbϮݞn/㢗v2|^NK&9г&{PtIf]3w81^H3=?yf菾[$'xԎ~HI]y?ɨ୏zz/P
y][=;b7ٸHwQ
Ͱ+ޏǘ.~YA&఺Y+~#_KC6.)h;[9Z9Mtć~R+U{`S{POwA ^e^/6FApt^|3MoHr#%'Ю":0J`=1tee4go
bF,TTBE+bH,^H\}bF3z۬Z)|Bj`&LL͞-nG FQf%D`0z`
]؛7+)fB)lFO~o+dz6,yQ
 PmV^螈ZL9_V"ּYIXo-y.EqiK*8$,E+Lު*շ
*ӋZL@L]WWiKyR^EE+($%0uYv!~|@O;PyIjtxjrsLj"l
i8Hfl}p6e[jBEWKptCJM:$yL!Hjb
#ٖQ`d.Qh!dFH35?oyI*5N*2uN^0!!CUw9|;߿7zrNUT]gږ;k(+h=MSTƌ@Y>+-v9EҪey
m",+0I/H'*+{,Ԇ<"ElUq`.*9@$&v?""ùX,.9OB%y>R3fg+	L쩠]WNsA[
"k`q6bOp|8^LQ"Lt0*/$(QXC$s#QCiԽzR.KYGw1AEH8BQ]0Di8!>-PX[KCb3~v㹳v'g:
^b}s!,;#
5rW|o`25<9nSx3mf+};F%_9lF~{?	VOO8.yڶ`#ӥYOJ'ütEq]ɉs${I(+t0a&̓.NXLt9{0:zО˚\O9@xx}3nyGs?+0pzH̛kT|kJ'4څcX9cWaRr23rl|qpGd*BԌ/`frsaUh`=rN~1댐$'#uMD>^J|ng좉m>圿<:y%<<ԕ^Z!E)Ktʦ72~*O{/0aqeu^1_%`*RT&0:k]R]򪂥="z7l/#Gos͊oXx\Q}l}~$)sցU5؀~;nl\3jVd<Gm
<_B|ܑQKٴW2
FoEc
|&U/kK쥲fXWG+)P\`G+dAXkh>x7ުN_MPJ?_UE@X+ɪ3̢zFMe>VVPC
sz.g}VJz1fPfESk@GVX]2j>22::QM.KGo!KncBN&&*}bqb1ԮKrE3,|

^@ŠHMFRV/RzH"m9*5+?
79IZ>S1&EQO>v4Փ%p'gyE*俑7P
Nk%#ױ;QA2?Y<(Lq茰!6Zi|Xxe$3.kjT2GZYC-6)$Q*0[yqהpAGLE}yWolU-r}ƎyJqSg~;jgcJ5ɦ*zqpJQD3?^{q`otP=BxGdЃw	7sfZ[BFhzxB=P{]37&ac2fa;i	-Ss?uzo
zku$Hc]jL}“ua1In):Ӱ;QfTKCuOn?_A=㭁閬YSYm@')۸a^ױLf6if—ZTqgG:*v_@R6`u\k..p.j|b~oGKF|?Gg
=ae|k]|
f
ƞx
c*P6N>:
f
0M}S$7lGX~.0
+|~W^ܯ-ﻺWu~co=cSج
\OG2DYH;bl2W+X!:Ӻe#akc#F1qN5FPKW*PKnLargonaut/CursorOp.classUmSW>weEh|	%h/Dn,.K&itڙ|ig{$q<_`	v֤K5m9 zKOXU6MQRlKSMc!n-eMR*sp^6F2-&W/7fy&MMN`tA,n	E)n'GKaQ6z_%ÓXkRR}d\=&8ES	EfX3dB}c	HocҢ+cmR1=Ii[F&UqʿBh+R$@٢w'|BRicNED_DC{yqsz9v6/M?ԃʆ;֓LjAb9JM{"%>'9
1̺?ro**y7yC[RRJvK:ؘA1Ta\8]%˭lKiCnΰGSJZOnr[tT&HC<=%=]=	;d4=}8_)쬜J>C"`7#ژ8*0w
;C^B#q0ܵ)JOܮ}V$*7bL*UDnj.C^\vse7t
&>86kI]7yCWu50(^^>sP0WU%뺬IF/(U0!z/@P潒K|ȃc, wezځ$Ԏ|lƺtms$
LعH#:4Ccka3WXۉpfiS6\nOC6l`H]iT|Y*rY.#NtTil46H=I^:Nkq9RXTj? BːBI"Qf[6o4|aZ]iEd,f*SjYFBYY?V[&xޝQqߞCㅺ(59<)Z{tYipLK\T*+lyUŘ4kr")
b^"Zkz-~0
ъ?E6&<8/>p\Ћ`<>
!QW{F`n1`&#
$va&p5Whț8	6wD?	)no.#q$f3}?3rρHWvGg#K/|$p6#OhHĻ/B8!湬π9,ݶx-hrgX>_eCAU|\#2yO4~LF`6e3CHGv&b˃ʞo8p|_ 	L:v6ٶ+x:pI:a:>ny7ř12kY%Á
PKohi
PKnLargonaut/Context$.classS]kA=dhScUT*`B_b'ɘne!ł?%ޙ&Ppa޹9g~	9Vx4%OTJ%Nk17b,
v<gXtc!`onŐk_j!]muPDF
%A#5p6aJ?M2IjH oks#qp22dԑ3l^C+ZmJDdh(J)NXP]IBt姐21t39(Pť]~s(
]a"m^Dbu(K!Ջ*
*A_>2uLPH?@ejĭ3j9}	\gEjIQW)4cq@a,lQ9Ym	iMcl0PK|8}"PKnLargonaut/JObject$.classUkOQ=eʫ/+T(CERX䶬em[!&HbfwnRUٙ3gL|0g],:Z͝ܡÛL%ϋT	E_2H[;2kQQԖ5].C m?BPcYCo,9G+ <'$+EE/08ǍKH qн60	j$)~Bg?ıD^"aL6X(f0!&!|mVתDx+5Wsxp{kNvefW-;)1n#!\]-sgsCK&Ab)AZxUXJ2$
9|MY`ѼUщxb3̧.(<\aE:}Kh]}F17$2Lm>3Db3L?TPwzI]Ϻno2_dɩP0*cV!67kC0NIU$qM0WуI0*4P.hRU⎇Q0YjVT/'E}JZ24RI鐩+Ί,Z`6^>CWA7aI}K|MsW懚TXwkC䢾grf_/\DnT֢Uڲ-
U^&m|k[Z0MF艢OdmR#<4@6F7]Ӭ4зcv!,8`%
uB=uԵF9D8x7,y$
1Ngd虪cI.eD`)[+{ѕA_!C<1E9C"Bճ^.yygDOȝ6-xd,O_ሠtsτ07A"_PK2PKnLargonaut/JNumber$.classUkOQ=wXvi
BK<[Pa U_LnZf%+`$o&qv]ٝ9s̴73xɭiتf^)fzYK-嫶Z(غiLeUӨ禳hŴ,O<_W3t2A^y]1tQL'v10B*$\ٖnz?7Pd
]~{_2xRȐ{hUf~UCgѫ.xkل;Ж}buih4;l'
AҪ$2M`/dBkh&bi^
HOK{/Y:Ԛ
BÜfbhi<ڐ0^Dv-*bo&LiMiE_#ZD65{{-^l͢
l^x+nӋk_9I/"̚UtIN5֍w&mm]P~dgɊ|C'"tɊ_W	t.8O

E'JQ"u"$9vgy	p]nQr#S&$4E&@9ϸv)0~,(&J,9zHꆌIהe(-@)Ry	eyPܖ-Te2@VKb111ibbbW	F(wܖqd;|w](Bیl4B>4g$b46lBQ톶2
-mɼBw%ƨp0*t+t~R]RB>e}aS>ܰinC
Uه۰Bg}(t·ۨB0R..:1^4D~ß̥'PbBMl)=(ONAcFFϘ6zX뺙˥2?ڨse-nv[z, T0!{XΏj(,ո,kyܟN+8)jGfԡM-fdzS0ד1BD,IҮF1AUL*)F]GԱJtJ*uhA^A9Vy56ҠDn4d6z[a;FmJcT^hJtd
P
|hCZʇ6>U|C
yU&)ClQ}hٴmDnӆnoW΄:iמ87{F\{=n}QG{=GiWr8Ar
$B6ϧygg2Z.N	`ɨ\?#kuz^(\Bw:xx:k(Η<vA%H*">-cq𘃿NMb& ,Sdp3p!0R&4
U{řmSgض\CNW+"_K]EE"z]E"I誋ȒR
oȧ`Ix<"E\EE~t!uY!2zEv`"wE~un箷%E\E4o?\~Q欒JN.N{HY%ݢ9 6,Zl\(h	pâ-Jf,Zlܴ`%a*`imj-XEwiϋ4=kMAsni56YD/#A!"=pOp9lh~aO퟈K,/Wh*iNڠ
6J$mҶI.WI#ZfQ\!h*JGT2\?PK!PKnLargonaut/Argonauts.classeSSX7Z>Zl.Zqg"ZWP-v}dB3*f̼s=@!ٺej[Po7N!~}
Gss "(g;av׬op,ᠾf.e
<={cao8e_q2<q\AH407wXW~[coGv@T*4BtJXpn
F^lmpy0چ5-xOwz@CXy)ج?ޅjͪ{2EAȱmxO")95zXLHsoi&]kPuZӷx.T}?uID>=YՓ7L/8^$UGi#B
	reKT^,D϶x|%
K;eiaj-κgah~E	V<6LVZSB-ƀctL5M\4Bleؚ+H#vM#z,6D;()2wK%	?
n9xԕ^d@zܙt{=
#jNOl:.!ZUNb_Swlǧ%^O@ET
b	xύS3jM2V٫dh%/slsefu:na=bP(
)x'>bcO,`h
$_y	CXj3C/QُMAܨ8I
~Cq)hC+Wߎf^E*7L~hOܚĖndH;mݢC|(-f0=}z"][E}(ȆI6}<L|à'{R1}]7}/q`@,qr~ߔSqaF0#oR/^B~XT*j;O-Aw^}$]Л
L4ݍ9]u5f4$:&׈Jsh Ӵyթ6r
Q1E}zZxƌL"VJp7,;mҍ*ݨR)bixiDUѵj/9#ט͋",H"B>Dɛ'>PK
M{PKnLargonaut/CursorOpElement$.class}RMO@}C+~r1zxQLH$ޗjMmM?8D&QJ<uy~|&aUQ(9$@02@[1N k?^j@)10C&3/Ai ,N[G0nwiM(ut5/ŎJmT0k9B9T&Q0zc۝AۆAOoĂ%T݈m]60<2  bO>0аX&9V(I=6r_PKeDPKnLargonaut/CursorOpFind.classW[S^{˲,#Ld&D`'Ʌ;'b1	T6L䋜tNf:!Ig=}igotIKl	3hou׿=xMU)R1"JVs9mBf)WUA`pU
K$RRjֈoM1*%uyee8	;6Q$'-'Qڻ!*2c/Wv/re(ZeңP	Ib(ӣ~zѣ0.M,qxtG"i/$6M,z8h!Q2?tCD]b$$2G%1UܬyiOCK`%(=K|*>vFGlHz	e}8t9ipQF^uX(;Y*yғje&CnKkoލ̘Lk1RIm7+(ODɨ˸^?2tn̈r,[rz^r~&20Lz~pw"-vN19ڣ4I&InR>*hם׬$
&3<D%.Zvř(w_̯	Hwa6d|3?Bzm(5JYt`KM̥[Vvl_nslQi	RpɐL_%3EsBܸ;Z>g?x4-Vy?7Q|qA\vS8iXXK&ԑb3')NKKk|92e"?L둆Gĺ?}jFDyx1Jے$4(T7}5"򊓭"q,p4/=ĥng#"J1b}n&)XJ+֏xbWoHY+$%X1!)!rhG/c՝hQ^z#1|<2e>I>L9%p1:CAu))Umr?	L{"*I)*^ S*ZZȽjyZ(ґB 9V410)B}Ku{DּZ0"9	!Vww&Ժ:d)Y_i`B<\fhtMhsmoP)9&³qA/ê7

x-Q҂2ށw4Y,ޭA/3oF*,ͫ@=A ^ O|g-S8-c䞭sp8?M?[9;pOA`y@A[	[?
}E>yu38;DZ.DӚS!EssυaUBqpxQ˅KlH5\&>UaQ :JYZk%7UXZWBX`*;C8ɰDvR`\³x0yc$kim6H9$%$!'KO80Fn')/n
i	yEpflzlij1uV6E|^"2t1LB0r[&lYQ[.!P^o_+[Z_J66cEwR|Ugӊ]s9pa;~Cqъv&zta_;x)wOwIT"~Y}t{ΦD,ER4+C8m}dۧ˳לJ~wMr"Z5ыyM<(tuc$gN\_g$4[nsК\yO:
V> ^oUX쮣r_@_OWǢ_z]%gqmϫ.lvׇ4E1+s~Du&>=t=k鏿wV0fOKQ:,އ(߇	S"B{	mϡ__+;CC8ydɦEl_uu)c-#%A[h"QD,5a|	x>G_[CD&(\Qx g$fEhVL><%1KpvV83pb>mY>pŅbtX!·@`h.c(Ee`=ʨF̡兺5{xD7g9F$Z"q,'?j>bÖt&L=u&e]=h#l]zFgbV%Xq^@~]?_)~Nl:xmv6
2_tu|tX ~/6V8y	C4ra0B:8n߀崶x;itJ5HďVUI	DוcW"MDcbU`ژ܏}xD "B	`~@QH	. [B1z
 H1 H$VԦ,܊Io	>75F)N!͞('	%LϩoѺҾ_[ggEutajZ&<@gG]Y[]MiGڕ֏T7F~Hͬ@"0zj*тھk)MfI,?hj]=u4VՆ&&ժnk
tFnbROmw>G@iMn eNSiп;&c0l>Lcp$^0#	w$t
p\_		an{+;^;cJ B`C

!{0A*^bPKv%PKnLargonaut/DecodeResults.classW]WjoB‡,цVDk' hQk Bk`nz{f.욙f:s?kD5GW&y7߿	JA+5=#eCJzB|.Kr^?|th7ǫ9$Hኒ/cxӸTeYUYᅮT	_<{r&J8&+I\r}j;/l~͒9xrz.it3$BHOb({:bc$QZu%Tp&6"0X7cTN=3dǢ ;-FhB\LD|yUVݫj8yPGqKuٸH,ϔ5(d-	bپ'.J«L?Kϊ$.SB).mYzƵK!ʪ7-JnڙyF.^)?E~bx5oW\S%oNH9$*Azz:5DAAҔ>!i$AwN{߬&ңT,C6A6&vbȗ1̞Czyk!>ʾH$AqfφG
5ec	O'ۉAyS&iOY'ICQ"-ȿf\6v伋KHWkƽ!S#d"4?î:K&Y>LVp3DS,GšaS*Ľb:Q-'rb)ywC?#k4u"0Y!=UYr_̼͉^;@"nW=5lj_/URM!`b 
8f
		"5Y
|F7	`a	`KvPE([bU4sFzpW
^9^Boz|W98``3,^:f#/6jÈYTG(uٞ_xl0PюWu4#|!Fg
5#PKMxf/آ׬fbTHaI :@=JK&.f,s4$n@7Di5&VQ/ +:ϲ^]qV@5!7joiUDt,r	Hps2ZyyGZpzgǶ?Aɭv\_XO琲g‰a@xP*e֥rvW]6?[
=3hE;{v~/!56w:dҌATL}o.BI	v[3$6uzW[[y7N
}QoƦjZoפWA@YdP6I{,O*ӡ4G:fLY#*Yi}TOPK11giGPKnLargonaut/EncodeJson$.class}|[Gĉ8888'q:Ҩ heGIVjP ]
Q
]ʲQBY(%T}P[.t~eY,˳ey̹+kC۲}ɏ{ggtgkxiBHJj#'DȁPJNτcNEL^~,d'Fñ0%eΝa߮r򃇼G|{dewQRɍ)JVJP*Vh|DtAeQW&ԕ;Dt(Ҿ;~6rU#&fA"pdW]yND4+(-{cHN-+CbpFgW♁-?|2>YdDFjwGOx#ѡpL}Mءpd{;"x,[垓TBYC
]su6r"2b"t}QGdy,2
5D˓7lWqK1[8D&v#X,EY_EIkQJ¡l'*)#iT5
aXe`Cn]9^rR/H2F'rne芄2*L>*S*\*:fՓO

;I4q2愪-`On{c.a6TVG啶ym\nQYek+s'$Hn!z-,ÑQ?1ぱӱHtyh1`[D##DXƧcɞU,ɉ$BNB٪h͉x`*a/윰"x
n5E>.3zj	2Q;Bm7N	j@IA-9Z:)|w)зgْ='& ʙxSj&>1LCω=;2Ҧ''J9{{5g_(E!dȞ"?̉wwsvISwf
PMQ3_s{}\Ka١n!䣎Sd!tGN ̇P3jaj&!݊BҚ'Q WP]gt|QW>2.KrS\FP׼a>Bqf/g_,f6=aeiLVjOvU<_x6L~+JVf}|gcf軭*10F02fVIGO<9ģZ9XZ'
s3c^~JYuR+[|gEL+}Yp ʜ;³V^;b^g鷬'
}=s~VѓZ#'8dXwkS'
38,d-tRk9+~IS`:)%6:s=Nɒ;'%s4g'!c-”8]N	T4]tkVV`R`a@w@7+X)$]`[6VX.=]`;+PNؑ.U
LIat;YF5T͊4+E֩tt"NU.UK)IUdGԣ٢*ҭ*1PtlSv+ETXwnW(ETPtP*ETQ)EV٩**EBۯٯ*BSTQ+EWG!Ifm)maU>ùgq!]ӣFj= b1S'ۀ
.ֽӛ-Ӱjcݟ'|t071}jj𝞀7ғEq1[ݜN(uL{?#SH괄b/5x4AkzFGiʹJdPMIUJΕYJJ(k)sNoW}`9Â+1r	.wp]K[l;ML|gƹJ=\om*c[)}K̂dT3QU9ϙ@O{DYn}zVܢ,KHfs['"/GF[JLP!t#Kğm|>f[=_K0&R>1GÈG!hgmU')zAɒSqǮaeآeoG(}T
qYC	ꑐR	-J	_1GR/ig}րiqٳ=fKEmH.Ć/XïYqRsM=J6㟗4oi~̿J7;`Ck0>Nj#1.[hVj̣ZoRX
>Z̺5X1OjAFwcAJLh>Ժ#GUh8ɜG	);lݏJL:iϔ'Ue*UBgJONɂncV6nfϙSu(>e&xu,3'0dgJֽr6)=Y'~K1RAB*֛dbm'vRXk;YX/*;q(A`'1e5Nk4+b;iQ
;YXv;q*V*VN܊Uk'Ū6Ūj.j#S5D9o$0}f'zxl:JIYg'%[}LvkГ#*]Uε#9㍏
"+uWjׯ8A4x6;|2>k3%nP%zc9*Jp0x<	gI ='Y25h\1۠!r"C~4a?((&
t3Ld0|t%oKZj%Ev
vu}c"|[TDE;mWQܗqP*l}Kl]FNǢYK)`u-ݶ`RBr5d!K~E(5}&e|htO/%l7 GOc#Jao%YG#0KG":nlh 2"{";«u^`<SѡoM(ubV$NƏJ"L&'Nm)~eg#6
ذc$Wh]'	>tZC@
Ga4#)th֘1IqG"e1lFgGzkIi7ܥiJomklOGk1ºFAdɤMGL*==M1f423^NK{#2@ZK3f%\BUQm%ƶ#tSWC%N!,©_]DTcʆ;[6sk4Db܌]>8yعbčɝt!!F`Ly_}N	>sZoLiNtYjM0rxcsǷ;5i u2éYJ(P	kэԑJgcWW#,LF4\&E۵zX&h,6RT!Mv▮fPW^V*)_fZ+1i4-|-tG,--j,4gQ~M
3]~R,UƂ4#kI-^]kJ+?+;CuCaT]$jbttZUͺU^B^ԋ%hSG`	R\喒"KSJ
tr2%K
gVFsDXXt%W~R[59M=V}iΨv*Wv-}C+xpJ{/J-\Ź.+bg9Ӹ#.p!$b ):LRR;c8%0ȯhnES0MRJ5h%9pp5Mp6;YKmgqo{+ڿT$FqGڃ]j8c
sn_(1k
%6kJmgw+ڿ%Z,g6͟3n
WqMXCyOMu_]r4~LOC(ٰh*U#cÉP}wlؑhB7KDcGaY'wGOx#ѡpxU?l:Ro|l nbpB'¬(Bq_\ nOGf>x<	+Rl3.dx$< ͩ|Q2ŷjֹ^#njR;u:TE溄j7O]32oε~5˷W׸QɲϐW62E(쉅GG#,?;8>dѱH+.Nb#;ORABj,#v6RɎq긆[:e+Uux긞;&7L:^=qIMYuL*~ұSu7cx;v7cx;nSq';Ro%n	3+Oc3p@Nr)WJ6w{savN9KDnf͝nUh)+P.\-wM]]qLu^R12ܛ=IHnVNrr,ƊVB#䨴Wt#	viTK7V^-|zM&\a
zA \Aܜ
b2-"lZ.f-mIylj16Xi
$.+FcmdD4"?B*xÎI'馻+t6]MW(M5ʬN2:1
9KΉdv#ItWRaW;vŎ]+]kY%N\թqEr21Ǣ$3ݵ~*vV]ĮUb*uY$N:I;y:f72,fu';]A]®VaWU*jU&U.1rNO@"a,akw,N?Kw=`k5z
v^tXDXX7!{E $`k3q,I?Or\)b(J-Rb(J-Rf-uڰ0_.MQ$NvZ)ahuZVahuZV)u?*$A 7U
~lİف:&_CWaj=Zcj=Zcj*XTIzRA_?N>!9^6wؓҡI)7`
zހ7`
zހ7`
z:X1.!
 ts!aWp\6ʁp,KϥxRhD(FhD(FhD(FQK@	(mrI
`þ6-gqT&ܧFh&	iBh&	iBh&	iBhhzt+2/&_@+;br,O/z@)P5#TU3BՌP5#TU3BՌP5#TU3BՌP5#T
T`]fr	h1yv
/op$4tTj t-]Bׂе t-]Bׂе t-]Bׂе t-]Bע@3̪8 ^]U_'@O1qNHC9BD(t"N҉P:J'BD(t"N҉P:J%X2Z0`P`>. +?BZu$IC{Yж"m+Bۊж"m+Bۊж"m+Bۊж"m+Bۊж*Ђj$ 5E9{
اZecEk)jBB]v!.څPjBB]v!.څPjBRyf~@?h?F#mxGmG(5z7BFw#nލлz7BFw#nލлz7BF
`Z			DW:֌IT|_Tx
RA*ۗ[΅m"e|V\KhiLyKLEt&r*
kO[ZRea-niFK5t.-xvK4Zj(fZZz]vKk5Zj)۳[ZRka->-k
-mhޘRFK]t>-m/;[ڡ-hZzSvKhiwa-ݙқ[F얮hZnFK7[[:Lfz|s}odoK7FG%*Ҝ:Ӽբq;6na2;@RӼlb9א6J1SϚ=Ua窰sU4,etfOIj͞C̞;L#$!hj#U-#ȚtbkZc28@R$5#IG=E6xt짞FSKjB\Wcp\=WOG
\ IHj.n1\;\,`:*	Vг4x
FdMAa|#߈7b|#g25@RSP$5#)Q')(T6uk+hj)z
ӌ4#8N3ӌ4#8<Y$Iͬ8Iͬ']6.1=o!'jHքDs"xNω9<'`2!0@R$5!#	Q'	$5!0ARlBbBP:a*wwd=Fp]u!.ׅ\Bp]nf)ϩH9 I=sQzN=NRϩϓs	zN}7I=揚dϩϩN6:Hxd=E= ߃{|A=^`xt>ǣx<>ǣwx~ǣ&%^0I
bcwzTǣUIZDs>Ӂt 9HNӁt 9HNӁt 9HNYv h+&tM5`Mr:Z.@SX*	a^*9+T,}Aҝqz#Iˢ"׍u#yH^7׍u#yH^7׍u#yH^7M/2ke@
4.+&u+u+ Wi?_wH8r%^̑TXD?N.z}4kdMJ:IhAr{$Ar{$Ar{$Ar{C̪^
r{*bqAn\ք h hFY-!>:Cy+T,ec~?Bz!XnM"H~/ߋ"H~/ߋ"H~/ߋ"H~/ĬпA~/Ƞ dqA~/`%X^*.{A.
{A2hϦ 5
^SB>FR>!ݣu/_a8k4؏V8P}(>GчCq8P}(>GчCqǙU=ԀԂ5.2kBdR!>IX8@&`qˤ	,>V"@0-D0D+T,mdja"Gc]?ңOExQ<^ExQ<^ExQ<^ExQ<^^fV5y@2ZVL2Z	ָd
	!/!/h5Xx 5`]ւe_'@Pw+TPr+T,b_ޝk
XՏGqQ\(~W?ՏGqQ\(~W?Տ0z? 2+&2k\dVքW?ȬB\ F.
q̚$2klX\f-`%"%s]!8LD+:שX*KDZ?B|ؐ%oCP|>CP|>CP|>CP|>CZq@+	@`M@ dKB|>:.@2tW*m {7K"VoSƟXWձ1IӋ=GqQ~GqQ~GqQ~GqQ~GqQ~j!!N?ȴdZָdքd!N?ȴ	B~i3X8 .qANL7e
_PQ"ؿ޿Q~۶zf	ScSy6Po@Po@Po@Po@Po@P?EWzK~$ӵS7l
r׿[_X.k-MreEp햻^XכqL%~,EMzY\]/u2uuu>t)w"Od^'3]o^2]w];qLWLwz+I8Y$Yrl&t	z_lRy&_Neދ/N}Kݛ?gwٖۥI%1+َo%>/Uw?b֝b!٩:Y`k^۾DE)÷Ix-|%/>Ll38|{/f>`
J;}r4x/
;W}n	x,^
/F>eI
_= FrX|LOtaEa	v
7x'6l+&/mX۪a%8l{Ű-֢¶aXza5lE-փUm0#
}&`&<
`cv`k
Zn}\av'7\rPKVs*"PKaL}~+META-INF/MANIFEST.MFPK

aL	argonaut/PK

aLargonaut/internal/PKnLz
'argonaut/EncodeJsonNumber$$anon$3.classPKnL+&!}argonaut/EncodeJson$$anon$2.classPKnLD*M$argonaut/internal/MacrosCompat.classPKnL0sO	argonaut/CursorOpDownAt.classPKnL%'argonaut/EncodeJsonNumber$$anon$8.classPKnLnLargonaut/JsonObject$.classPKnL+#N<7argonaut/Parse.classPKnL@-GRJ5argonaut/Argonaut.classPKnLˍ$Ohdargonaut/EncodeJsons.classPKnLKz	F9argonaut/PrettyParams$.classPKnL
{m#8argonaut/CursorOpDeleteGoLast.classPKnL9CsX
wargonaut/El.classPKnLg'argonaut/EncodeJsonNumber$$anon$1.classPKnL*j(-nargonaut/JArray$.classPKnL^argonaut/CursorOpRight.classPKnL|
)argonaut/internal/Macros$$anonfun$1.classPKnLWVEargonaut/CursorOpRightN.classPKnLh3argonaut/CursorOpLeft$.classPKnL+.argonaut/internal/Macros$$typecreator3$1.classPKnL{Zargonaut/ACursor$.classPKnL*$Rargonaut/EncodeJsonKey$$anon$1.classPKnL+m\.3dargonaut/CursorOpUp$.classPKnLX{;(argonaut/EncodeJsonNumber$$anon$13.classPKnL:">argonaut/CursorHistory$.classPKnLo~Cargonaut/StringEscaping.classPKnL9T1argonaut/StringWrap$.classPKnL6EMtargonaut/CObject.classPKnL
R<4argonaut/CodecJson.classPKnLG7,Aargonaut/CursorOpUp.classPKnL0+#JFargonaut/GeneratedEncodeJsons.classPKnL$8argonaut/JsonBigDecimal$.classPKnL[C96;argonaut/Context.classPKnLvAA:+?argonaut/JsonParser$JsonObjectBuilder.classPKnLWÔ%Hargonaut/CursorOpDeleteGoParent.classPKnLHB!CMargonaut/CursorOpSetRights$.classPKnLZ$Pargonaut/CursorOpDeleteGoFirst.classPKnL'Vargonaut/EncodeJsonNumber$$anon$2.classPKnL |Xargonaut/CursorOpFirst.classPKnL8
/]argonaut/JString$.classPKnLh/9~`argonaut/JsonLong$.classPKnL^	adargonaut/CursorOpField.classPKnLb Mmargonaut/JsonObjects.classPKnL}@ oargonaut/CursorOpSetLefts$.classPKnL?ޑrargonaut/CursorOpDownN.classPKnL+D9$
{argonaut/CObject$.classPKnL\9{;$Uargonaut/CursorOpDeleteGoLeft$.classPKnLYP
Aargonaut/CursorOpRightN$.classPKnL
6g!oargonaut/DecodeJson$$anon$1.classPKnLN?%argonaut/CursorOpDownN$.classPKnL_~
)argonaut/internal/Macros$$anonfun$2.classPKnL'k5argonaut/CursorOpFirst$.classPKnL<
&qargonaut/ParseWrap.classPKnL|0ljargonaut/ObjectContext$.classPKnL8<-{!argonaut/Cursor.classPKnL$א/zargonaut/PrettyParams.classPKnL5#a8xargonaut/StringEscaping$.classPKnLi4~'argonaut/EncodeJsonNumber$$anon$4.classPKnLBQ/a!7argonaut/EncodeJson$$anon$1.classPKnLRargonaut/Reattempt.classPKaL;+argonaut/Info$.classPKnL*^D%Margonaut/CursorOpDeleteGoRight$.classPKnLu16)"argonaut/GeneratedCodecJsons.classPKnL(Q	jargonaut/JsonBigDecimal.classPKnLO4i
;&argonaut/JsonObject.classPKnLF88-argonaut/Json$.classPKnLn	5argonaut/JsonLong.classPKnL>˵?argonaut/El$.classPKnL;
}'Cargonaut/JsonNumber.classPKnLk^Wargonaut/CursorOpLeft.classPKnL*];z\argonaut/StringWraps.classPKnL|13n`argonaut/CursorOpRightAt$.classPKnLu 
cargonaut/ObjectContext.classPKnLiLVnargonaut/ArrayContext$.classPKaLkeWMrargonaut/Info.classPKnLam=&ztargonaut/CursorOpDeleteGoParent$.classPKnL$!vKxargonaut/ACursors.classPKnLC('-{argonaut/EncodePossibleJsonNumber.classPKnLf3
~}argonaut/ArrayContext.classPKnLKc7argonaut/JString.classPKnL%]"argonaut/JsonDecimal$.classPKnL
TE
pargonaut/JsonParser.classPKnL>oargonaut/JsonNumber$.classPKnL6C%argonaut/CursorOpDeleteGoFirst$.classPKnLzMCargonaut/HCursors.classPKnLckargonaut/Contexts$$anon$2.classPKnLe4"argonaut/CursorOpDeleteLefts.classPKnLc0)Ѷargonaut/CursorOpDownAt$.classPKnLM3}ΙMargonaut/Argonaut$.classPKnLQIaTargonaut/CursorHistorys.classPKnL&vFgXargonaut/CodecJson$.classPKnLZ
?argonaut/Contexts.classPKnLK	C argonaut/CursorOpSetRights.classPKnL[2<άargonaut/Cursor$.classPKnLh0)߮argonaut/CursorOpLeftAt$.classPKnL5,-[argonaut/CursorOpFind$.classPKnLʵi$ҵargonaut/JNull.classPKnLneargonaut/JNumber.classPKnLsصb!argonaut/DecodeJson$$anon$3.classPKnLUUB/argonaut/JsonIdentity.classPKnLU?7argonaut/CursorOpElement.classPKnL:iG	5Wargonaut/CursorOpSetLefts.classPKnL~-~/argonaut/JsonIdentity$.classPKnLl]$argonaut/CursorOpDeleteGoRight.classPKnLJHw:argonaut/PrettyParamss.classPKnLA~3D$argonaut/CursorOpDeleteRights$.classPKnL}v4bargonaut/CursorOpRight$.classPKnLto#argonaut/GeneratedDecodeJsons.classPKnL)&yargonaut/JBool.classPKnLõS!Targonaut/CJson$.classPKnLr
3argonaut/ContextElements.classPKnL-"U4argonaut/Json.classPKnL2	 argonaut/CursorOpDownField.classPKnL*}f argonaut/CodecJson$$anon$2.classPKnLQ@G4{argonaut/DecodeResult.classPKnLy8uargonaut/CArray$.classPKnL/fHargonaut/CodecJsons.classPKnLx Sargonaut/CursorOpDownArray.classPKnL}0DH	argonaut/EncodeJsonKey$.classPKnLb9!Rargonaut/HCursor.classPKnLU}2	argonaut/StringWrap.classPKnLM]	argonaut/JObject.classPKnL9D'<ā$	argonaut/DecodeJson.classPKnLe
2v`	argonaut/DecodeJson$.classPKnLBE?Ԓ	argonaut/CursorOpLeftN$.classPKnL6q.	F$^	argonaut/CursorOpDeleteGoField.classPKnLAQ
(ޟ	argonaut/EncodeJsonNumber$$anon$10.classPKnLOA	argonaut/ContextElement.classPKnLoD[Q(ۨ	argonaut/EncodeJsonNumber$$anon$11.classPKnL>	argonaut/JsonIdentitys.classPKnLSޯ	argonaut/CursorOp$.classPKnL"(R'w	argonaut/EncodeJsonNumber$$anon$9.classPKnLL;,	argonaut/JsonParser$JsonObjectBuilder$.classPKnLՔ!	argonaut/DecodeJson$$anon$2.classPKnL*:	argonaut/DecodeJsons.classPKnL='PU	argonaut/internal/Macros$.classPKnL**

argonaut/DecodeResult$.classPKnL.cB!B
argonaut/CursorOpDownArray$.classPKnL>$9!
argonaut/JsonObjectInstance.classPKnLTtc	J7
argonaut/JsonParser$.classPKnL3wT
argonaut/CursorOpLast.classPKnL"Y
argonaut/CursorOps.classPKnLղ:
"\
argonaut/JsonObjectInstance$.classPKnLs4ba
argonaut/JBool$.classPKnLoG#ee
argonaut/CursorOpDeleteRights.classPKnL<	j
argonaut/EncodeJsonKey.classPKnL

(p
argonaut/CArray.classPKnL]ٖvO$~
argonaut/EncodeJsonKey$$anon$2.classPKnLr4.ۀ
argonaut/internal/Macros$$typecreator2$1.classPKnLI@7
argonaut/Cursors.classPKnL*EoL	
argonaut/CursorOpRightAt.classPKnL(W#
argonaut/JNull$.classPKnL	4
argonaut/Reattempt$.classPKnLz:	
argonaut/Jsons.classPKnL\Ů
argonaut/Context$$anon$1.classPKnL(ǰ
argonaut/EncodeJsonNumber$$anon$14.classPKnL9Ń{'
argonaut/EncodeJsonNumber$$anon$6.classPKnLX4C#
argonaut/CursorOpDeleteLefts$.classPKnL5H"v
argonaut/StringWraps$$anon$1.classPKnLQC$x
argonaut/CursorOpDeleteGoLast$.classPKnLM$
argonaut/JsonDecimal.classPKnLU!
argonaut/DecodeJson$$anon$4.classPKnL_M%

argonaut/CursorOpDeleteGoField$.classPKnLk
argonaut/CursorHistory.classPKnL/	Z
argonaut/JArray.classPKnLZ
argonaut/CJson.classPKnL7cϊP!
argonaut/DecodeJson$$anon$5.classPKnL~Yd@ 1qargonaut/EncodeJson.classPKnL#O
!#argonaut/CursorOpDownField$.classPKnL8US	T'argonaut/CursorOpLeftAt.classPKnLe\X(0argonaut/EncodeJsonNumber$$anon$12.classPKnLp.4argonaut/internal/Macros$$typecreator1$1.classPKnL%,j19argonaut/CursorOpLast$.classPKnL'x=argonaut/EncodeJsonNumber$$anon$7.classPKnLp?argonaut/CursorOpField$.classPKnL>#7Cargonaut/CursorOpDeleteGoLeft.classPKnLs'ewHargonaut/ACursor.classPKnL	s-&.pargonaut/internal/Macros.classPKnLmY$]vargonaut/CursorOpElements.classPKnLW*xargonaut/CursorOpLeftN.classPKnLohi
Margonaut/CursorOp.classPKnL|8}"pargonaut/Context$.classPKnLԡ[׉argonaut/JObject$.classPKnL2#argonaut/HCursor$.classPKnLmdA[Hargonaut/JNumber$.classPKnL! argonaut/EncodeJsonNumber$.classPKnLgͥ1טargonaut/Argonauts.classPKnL{?Nargonaut/ContextElement$.classPKnLX
&Cvɝքg;4O+1|GGH
l:zݻp_(ǣ;Z7t7M7_JnZZian5ݗnQnFB	jv#G\CIcc{3.3;Xa;*hSoODPof38L7$݉.
M84Zj@Bb?	\lN@#3to4wKh
{E.'w~]ʹ~Wd
~K8,4D\(RJVVO"-sNiK5UqnK-Ų.0/}[ɕJl4KVjUBL::! PYi*Fhv%^\.9Te/L	-O?v'WPE؆
T0|>B^*-t9*Y+.DTT>Պ',0a\8ZJDV|wH*zpUȨ{c'91>-QH-M*k^W+?`^Blӎr[$ĊX$c,e	y]2PK
h<P(junit/extensions/ActiveTestSuite$1.classSMo@}q8$-Q@ip!uښ8*JHMŵ%J
pG!ZPD$lyfvΌ@0H[2JTpVwmཱྀ[yx.r/0z*PVHƩO\ԛJl1xPD|xSǩH~s >s"c)Px|^hԬ‘럸ιRW@|2:8XiWe.i4G
N]"agd2	&v`↉eMT`egb&b$PWi
Μ$XO-N<_]s0"1\YU+rv#-~59J<
7wg({3hzH4MR3|PS_G+w+FKPQ {?.3\5dLkX"uh3#Zk;yf
2 ޥ7xgNPK
h<`ǫ&junit/extensions/ActiveTestSuite.classUmSU=7	,,+	DZk-j
PKt񋟙03zeIB0g}ssxd#zT/ \[eւ6p듊X/-|eaU TSs)C@^iF_|O-
$ӏRHW=_E϶dn5x2Zmc7s|Ru/V݋R/C釥6F)Y+TnJ
ò&PuiF8NӾ?v^U3T7E"
nxsgf;c6T<3@̭9GAQA\-|$è_`ly
X11	ӕ۬Skp>úܦ3˜p^h_58yvь\Ќusp	cz˔^;_4 Lefk<Ԁ;핿V`Wi
	
AÏ)=YEJ~Sy;
L󕁮}]|ZY>}̝%F_F96w0 Ői9Nxmx]g,cr!w#h]\&ҕ>uըXb'K[8Y&3)rb?RaUyT+4`cK֖MtN<OYhf_h&*w\CT$}{X2f_U֚u_(VwZFؚ5RZ%Mj}x0vs0xC3xW-A`.Փ6]G[\]\P%#Ia8
*W0!s3W7ܖ㦂E }@4D!`_wt}d"'wK Idj,y9\SM|:5R7t|>VҩQL?NEMhMJ愧u-ٰ<8DC{"ب9M-4i⑃0l_m_&	J:&1?)vzX`tSw)nAk();Dv(}uu)nu"4hlTiju:f5~Gipr	s>^
`*7|*"	x
×g/r.b~M8Вwp겚.d\Q1
54VcI50.i[bZ`[{z*症bxGuuPK
h$͌T'=͎=DV >#©u'bhqI?(ywtN~Ĕ>72sI5+~](,%֧Qj6ݸY.b&^-mDW`J7U*CtP}H*yH2.Y
`ר8CRSnQ>GZTgq>exTX$f邠x~PK
h!Zhӳ	2RZ	KVG7B9Es}z[*G)	Oo
9v<#kw =(uZFQ~{J]Wyi?Zپˉ(iL]"2`˸ř.ͧ-ҁ}`+Y8
dw~Wy_MњIfob; *F/PK
h<γ)o	junit/framework/Assert.classixTg,wr3	bBI$4BKL^
қ&t27@pmZEZ֥ԅ
֭u~O.;3;8aN^|HŇ5#a
>A'Uahhin|^<ʵT|AC3ȍ/x\Op*Or)_հOs|M5p܃opM{kgy9|?w]yAƃ{у.YʪI
UVt̙cyXn$o^]oj{8jŬXS"+l[
|wۏڸNL(^A]^܊/@alu?h;G֘O$OY?+^øƸW%:ty}~*.zc`M=lbK,9ɒ?aaL=R?cTƆt{~#)a<4`]no^O`ofB5QF͍
SƜ57/[[/~{G9s0h@g/n|Il>nbf,&w{>&+ͽ9jչ'HɭUnv݄sx2-RM'@ry$_,`*ıD7#U
YfnRXn2Hj]iCeYhsTY0}5*ARxO5%nJh:
5jw)Y=XQ%A	
cTQasJc%N&ؐU.41*B,[bҧPZi1m1wR Q\茵c]"*Σl]\t)Ȇd/Fhg%`;FXdW"<	>BP{G#DtRLjivQ`vS{Rf{p j^IHT%ԞA3^[b
eB-+o{R&/DcOΣrY7:Z- /c-ű"OƇ'~2>$=p>dÓ!ۓ!ɤTvU*CmO|[p.
e?yh[Z.T,rnҩKSwvVYBDqp)DwCje=ghx+́jEB^*bkbk;R.8b`Kkі_{veu\RA2 I:=R g3H8A9 T+8wKAe;Jp}/9l%ArQЩu獂CJ܄!}{7iKU=wM5!u6Ghb5tn!8vgz%L'Ay-_,WB}#CfkNe8,Nq!GQf=`ylsT
6m$5&g*+F!$UQ5UQATPiW@=bRm>z!JenȾv{W7RVIYsg{a_^aۆj9	@j%ܡԁۋ3]
=BCF2"BDy*!IXs'H1rSv1
{Ҵ{Y";-Ӏc/+'ZC4xmWx ʛvkn.@Lc_=#=}e<i}LqIfdtC%#:ZVC7҅7-:g	3;apsZOv^ֱ];D4"(.`?E	wjҟPŁ32.:I¡CdmYK1,A :9IqA']X;pE4L|*
E(MD.;㯐l
D$?t_>
Szb۴#b6"Gu{!\].Pk%{O\j/|/u#^D	uh*
\%>Mݚ'ۻ[&y8-}e%pJFt3±#! g)CnwͱEk憕0|M)_6sG$y9TTq7R^PS4]$Ϝ7Z3'^&KѼ{JU&))PK
h<5.T'junit/framework/ComparisonFailure.classRmoA~\B(Zh{ߌƄ ~jǂWٻS&$Qƹ3?}`Rx6塊0lVEŦ-A٪KϰTs@)m!	i~[Hv7	*я1OgE27Nn3}i;'jj3$ڎ?cx\^%Rn3(5#
`p"dE(ZT'j1I]+ߛ5wpFPu+=-IOI>^	+"ed
%찪ŒvLG:X֑2#]Lv*4ј}{dϙS8RiRQ͆F7EoKMhXN^K_CzgOWٹhW,P\=cT`b_"
Zy	kIc>HV3MYd!+YwɊSn~XL!j;qN0H~y"HNr4IB,&W"'&sɱi\r1BPK
h<BO{'junit/framework/JUnit4TestAdapter.classVi[W~&YjR,E(j!0fĭ}]l}jlO?3B?]===wl(Q*WrHF0&Q8.OURHL%bk!UrpF!=pZgTsbxPCb~8Gh|㼊'T<)OxFų
Nꮫ~J'uk,.I;TcCX'Yсe>O[w$-b[Ogu	휈=}0kDOy#9LɓNjn*0P=B}e'
gHNRg'a1> q^)5kZhMM6X&"(yp΢
RUN[tFw
:SˑR0spIOW8r`l
"cTBM;iLLW
Ew ujWdwn1SiU,(XQ}cLا1vMKNI&NA6{dzSݳEmVnVRz13=95&.Rn|f7܄ntRx(cXDwIWstѵop庴@J0h/Q} y
/E
m&4UÍXe
U
u
͈xCÛء-h
{OAܩ"z5'*>>VOlI`TO195QT+,=pS?0|H0
]B$Jga}v~[cB7lIQz!KBQ]v3َcnɴVCBt#7n
yAۊ<]EIH\n9.-ֶ/jGD]}xg$9kX K'$фIm4qC+>#qTw6:(X<2e{4in:G[vhg"d6P3h9oN~S-h\w3 v%7ӻŏHy47tAϨͧw]7XMQ,k|J	"Q<,k=JҁEM
KKϻ
!7`
֢%Cz_{6dkE
xne+c-?Cܔc#Ǩ)zT-Pts9%(^C(r
a""S渌n-'
TF)XdXX!V7{LcGaf΂'	*/KBHm>N$?U:!/ Y ?QM#X5)͸
]Ar*5ID-WLk1M|o'xbX|M9 i IcC0ʏSU_:\src5ɪ1Bm{+g?
{V?JK9e,Rp빨W;b!jng"*[ŢҿNYf9<櫍a@0w3=6l}/LzYmd&kOG
++
TR%,jBUՓ,vu`>+ZC8$+O<@3\!&CwWxhq^)sPK
h<.junit/framework/JUnit4TestAdapterCache$1.classTkS@=ۖB䡂hD<t*}i6&I?Qw
s{w4:"%Nkc+]F3
fePOpW|Q6}q{w_2Cߧk?%!1&Yflt_}ȺcX޴v@{"KW)pk׌4MYsܴ.qy-U[Yz3W9dĉ4z
(@2镄0@Cx0lqm`x~?v]Pw[9Sfpq^&)2dx],c(x=5ȷh|bEJ`V5*iqrNM-;g
v*KOT(2P֛L\T>ZPǣaya8q$.e4n`Xi3R'Qc2S5G}9޵wq *k|,5ghl؞r$PcBlig2P.Hoz@ungcp:&y[GX:,"nb\xNI>2nঅ[gc-3KzL	-PᕰRYxX'ӧɺ2q/ZzLUc5V6וXB%v>{ᷣBlo.%I	,TǺಫZ_.]]R^[}r;fg3+Ue*OKoPb8Q'EB9]_p{ݬ,ӟM9:z}?+հ]WԊ+Lb⳨@ʴplpmg	Y(/A
D-	+
p$P/ѬrSDAт~ӬҭaˊEֶEDn,>Po(}.B?ꉻ{h,4=z
'rF$Cea-k[B21m[B틨lA}TEy`
 ŕ8Hhp@wnOy(ei#k38@AB@g-D-vl	u5'E4@Y}<9uxgnf),#\B7WӿT5Uc}.;C#ik"yɧʝEVvH/ӵ_o Z:dyYkf 稧Y5e'J1ȋdhhf{Eui[EWj?~M
_PK
h}A{|,AR:S{I1ʕF;=s%|r}CCbZI
@,p	fL\_zVE
.:T(KQ~%pJ>d}y7T#?Na>2LpkQNT?Ug*ieW=Rl9‚)q-J)2#g(#g$BU
PK
h<2̏ݘ!junit/framework/Protectable.class;o>CvNv.FFf
0F.׊Ԃbvn ?8(9-3'A 81)'U/+,A:4/D?(17<([I	PH~Nb^RaPHFQ~9H!##0]y 
فl&PK
h<>V9junit/framework/Test.classmM;
@cb"mҸX[
 *ĸ,<w{0
`q,ENԽSƮaCֳv0/vS-M恍<ct͛cBE+07$LC*:b_\ۄ@1u;4PK
h<<99
junit/framework/TestCase.classVYsUn24}%L2	@$kgI:icw.I}qRJ@I	>XZo,iʇ99|}ຊ:]
D>t~9: 9pG𨊅xE*t()UQ%/)lĐ
+|Xk*ÑSQ+'PHคeBI+xC ס3jq=cLU̼mL5ؽ5FGXt=ltkr.Ƽ,$	tע
J7[NMم7&~	h9=c,O`q`V*BqB^zܾN!6ݡO)jdLH+E@vg!7nxvoA"賌i'RKw
XHͲ~ښ[,TM7S>q{vJ !c 3%)3JWA)HNaʬ}vthU
.j
>.ӡ;`^p2s3H4\UH
0$0v 0w.0tk}f9G+7ӯ%^N} Tli|cJӏ$n@6k^
UƮʖ2ƧL.T>ݴd'fڽfi8 wS,p̕!r>5>vʄsSϴ|熺=G9Ĺ\ߒKA_|j'sv9g.ثw OY2l!nTc?Vp|WHBԪeHIV?	ɟ%v3ªWrET1YB͕PybJiG/G6GQUrqh!V
6`?l9DJVy_}ZTEXϑ
%p^,z ޔlfw+چŲҿ#~p.Z[sQL'a^V	bD%

*)P5Gu_1u{a6ͨ9Yr]l6ss%b'-'\c/X8E䣽iK$a]w2aÑO42}LO)e>|_S6oq7{rtL%nvdտgV"TqN8_`s;ow ^b}2BlwxCS%duK> 4Vd>*
"LXR忊JFBo3A/:{PK
h<0q2Q8!junit/framework/TestFailure.classU[SPN[6Fʵ""^[(UB9`m4gK>茔qWn#r?~0u=JnqS-1L)V3	}[k1wWpOEhX
)xaVVQSNloe)}F\|m[{Յ%VU[1Q.Nc"	5bN`<})omInVrЭQyi&1YM¢6K9*z2i>îP	Zsl-ȳr6岴!Lc%\m:"L{vbNhu-Z&Y[!d_Q?֬]&HƙTC?j8szGՄO90+[֠cI 2=e+VՐC3Y@U\s
#a
E
/@2P>
	66U3B!bhCJHt$PSj@kz?Z]Y$nƴgdO<\hqm!7X59@^+YdDY
Whz4I7iΣR9㔬T l-n!QNLLp^G8aߑ34PK
h2xXE3Dq\V{IxGb!aEc%alveتsj!WWgmR$ݖM
	yP>Oi`pI)t=Q$Ab%#KbS/U>Qq~	ٓ~@^싸,,;bŁQ8pP9XEz7LCB./jNcyQOa~@u-BD2̼8OPtK="/\ӟS-dES,@*51m͒u0o7?SGVCtQL8&ɾ#(=nx_"gԒD
e!)c*Ŧ14QYxPK
hK"ahӎ
.'rEFWq
ψc7!Yd-=y]	%,^*+gU|OeH.UpR/˰잿_ֳhf狶3p_Aa{rBTtK_5%v|)V',l:QFɐm^p
g*%YueVAKa)_IEޞRM8 6SΓm|d,TV֒~J|9gu(s1/î↸ϻ(Kl2ҊU".Cϭ(H∂:;eً9<7\5=zrXS
ӶmXN\gkUN)W/q38aF~G,$Jؚ1T]]ڌ-v}Q/o?0r丹4m5S{TYgD/0M|BPQRR0NwFhͤb}
n9p*;F+N5rC+xhV(F>
=Нf{\1^ɬ6-NjOK#b%3lP1y{\rɢBgDxPAw5Ӗ_Lp)
c"b\!|Rmb$*0S
j	n?a.4L`R	Sy>T\/K
iY82l3Κޯ4<]Ś_#;n6l:bI"kΔ*c.07X5гFr설DNv][WY+`\**F#6M33eAoNk8Zm75l3
R^w-[St%oF?H[zD1o$Zaƥ9`L|f5YV|vqHgS |?"VT)
UD)!wSO?:1xaڇ0w5O>|7iQS?ږӣ@{]
2PXt*+vң+ʦ<t8(&S8b'q/Ӵ}V2g\Sq"KaLBft̲dvc2s
xL[êބ yVzgl
k8AmF=A{OzQ5|qMS{|8vaMDVA	}7*W fFnl!C#DW2$2\.)7D(1K%~C,)KHoW=IxGŸA5}P&P&_	e$$
}&E{Su}˩mJG׽}`xdy`8{= {/QI'I|H|5p@֧BjjT%4TT:{ְk!7KE=>IQ$iKѳs\{q7/K̯W\FS<9'"8s׎b(p@Fx-NU9
Z'=WE5$2>#{Fuiax7)≷wh
ܻɛA<PߒhD.^4z gV,.ݤ+-ƃ?eDl;~;
H`m
,,2d[
m0Y{^vj끖}QMK!TUYZTmAZ&CFh~,aZnd6(T͘
{bXXX.HۭPutj>H4t+R\>2T"{4C'ҙ{n3f,gʷɃX6\Nof
b82G3GxHR듎ǒc|ۓ.||zM7gstJhnv8P*rs3qẹIn%=IccfM_44Œ{q3usӦ6B}(tJ;:T@a ܶPXzFtDT@Se55LpЭrt^VcBO.R)p"IQfb5(chz xڥf5>I	""<$rfF|i{5/}¦hr( HП
΃	S<7qO[w҉e&=@~3VhX&^(iH*Y3cN	u5оT2_A–+cQϭe49l6yStT|@TlDs9rwzƮwt/zy[\xdl+tx!T+аc5BFΩ\a2}ICL1+Vjjl
	ʗɧXq擖U=VX%$?h;0N
d"Wh-	Djʼ`_Kʜtٗψ¼mez`)5wURA3iΘ)iv3A];pG.u!e'%n!,?ai:N}Ldcf^ܛ8Ƶt8bix.FBcy&\@UtA>,BP}$v>
c5=Ϣvm=AmG]K1Y}za>Zg IW.`r-cLZOOM+QIB3|0I|"qf7z܊=3D.^rهwpS	-8J.Xc&kF9z=:9w7ez9JrfBУYR&7#Cbd3}N'TyYM$-M%J'MnZsj8JɈd1j83NMh:E)oqgFĹ??g
⼅-䌈Sv2.zSLKoZL!l&c=a<6Nv(ز2M{N.NR>bx v2QW[Ilז:Lyۣ1Y:Χ=dY)3rK0N+Lv˪2Q%l}.>@8m2(CVir(x]hAWY:X@in=ޓI|e1yl#?;氓-*}*Gsj{_ v>X/}F/}
LMWD9#OA,ҳ?e
PGd;hCQי&^}>Ⱦvwx	9^:*H$G 7oд3Mjr}Mc;zvV|G1;<&-;?a	?XV|@t[K쐮]&WTnbAii['m}/;EoѩQO}tOddޅN9	V>bm
2>?\GG\wȳS.pܡUrgZX>ns
#-f-fiOibWA(ݥU@U:7\{`qweu*늮"ݛV0_wΝoh	ɠFH7
s\::ʉ)4>T{ގM[6vl?;kIĒ-Q;O`ڐJfXKd-&GV0:gv<Ѳ#v\#vdbV0ql'l+cIoO )2۫C|R}:=:twleSĮX:.>Rsf%M&tX2N
*`Pږ%Kܟ
ZGSC-B	I7ӤeyCyCURN(9:#x1WNĎXE)\g:8CYqb8dl:k
qD>/Riahb'凬L#N5+MmJSixatꨄHdws,Ȧ!nE9d[ŔёPG%->haW!T}BcȳÄ%G:AC8{	X{4ېe2){s*ˇ~E#3VҖ<X
kK$Xb]/1SH4)ۖwޙ+nW:,@/E:9{+

XO-25V"6ֺWF/ӀB	n8Sbۺ@vJ)<4ǁx@wtnr3&
&pɀDfQ[_?Lv^E}I|E/П|#0黲z HOxBUu>d}7̀<:LV^.UR+[Z*l1}jƷ|;߁qMmf3v~~%(ڵ 
?wJxeAnCf;ߓo'v2|
Rq+ux!x'Gy;K3:sQf|R _YH99·Kp..9<_U`;˟9Z9LApi:O#RUM΁V"O6W:0ml-m9Z$zP,/`zLӐuyjepLP2rYID7 {d&~`]FqH+A1^J0d4eɦJGc@zw3uD

W@WoCh.~	|d4[P_3xB_yW=4GYTȧUG搀l?O아܊v}#_w~Utܻҕ]=
*/o.͇{;Wω<YlъHa"KԒQ~VrYYVD
HHʳ.>Gn+a@!Oo=4j+MRhU2SӀ7s4!LׅrލN+{[x$74NJ@x߸ɫ]
gy3\,rD]^.Έ7hIDsŷ/G[G"NR:
$KAVQAOa9QYj+{BZ<>N.k	tlwq{T4~j_ƻb3'?zw^J7dKynr:[u0Qx3%L_L}7S̠>JҔ{_W~?pr4-׳SԵ	uvċ`RY
e'^`u:}v*o5KovSu{;Ψtp0x+o1	~ʗASWpg@~bK?T	
b'g}_'Rש۞HOuw/eC蘵Y94J#9APEA]
`Dk{
x4ouNWBb:B.?ѿET5OnYr][xG~DӾ0a
y4^遣7nG:i
5::\E^5WeEl~SP/,질N9@tujc~v4QNb=y,:Oq2G{Z:(:/'zh\{)S`S
UTi3JEkx6mzΗPϥ.vг|^0\euVV7 ~)l_X*NIڿDB/抳TA-x"|5dsawk֟dOy0=hO hLGў@0<m/_5[Zܴpd6ч;}[
	#-*^Fy9m62_bKwČve f#y`huM¯6g{LΠ]Oi;SZPK
h+=uzrC>y!/v;{$MOQ\mMg9	'NwqQk $GVJHQ>P.eܲZsx[&DV[tahv0Ss?ig4op-^>MvrPK
hLiM+uƅGoKܹ{ӯOӠb!d>ӵe,F#v^Ct):Ԙ/d=lԢq.PaV4$)לT{G&PVZri{h;ߴ)ݙ59)jD;+C븴aeu?l`vkx
Zlj(W\ӳ5sS;4O8V鴌SEgU.A~qphc8`i4nΙFkXJ(5o򛆮pPFT2nҰWAj-fp*J;J%V֜[i[-:QX4[^2;kԦnNNӰ.\*יUq[z{¼bXᖚn-W.G-_qJϕ2׭dZPk{|qfa[:a-j`/؏8 dF,;ޱݛ89,{ɭ;2Qޟ0=|@Q,SK4p73Y,GJX3
R_?s-./
/5~aer//^T	~grr
-yr\k(kX9( Øcd&1TUTx[E
N_NA3V3o))C=WEJha2+*Rtٮ%1SgqgLn4SH=)'\r	r3m!ćͨ㣎J=ؼHs}är³|DHAplq^''eQMATwn-A":vC]rXwS:Og^9/ylq x0ЎpH< ". >'xRO ~^ؿ 3<+'_s:ė:!01OVZΝdn=v6޴dsڪkkk9}kGC̶T2cI{ZZ[wzGgߦvE'{m{;6tw4Wy
5xR1KCeg#v1sY3to\t3d,7bf3y
uD;Jf
5pFz QB"! H!LԈAow	{x]qD;2lC):'XTR'.G->le2 ef,Xy=l:jKWNrL
|
n
^l4Vֻ	#%TzCÜTP)ax4MPeAȿ[J`:+d
QG$_CAEjT L.S*!\`-v'v)džNnjqb!'PIUퟂw
TѕpCsOe.D/
+h
hzb%`
@ϡjVy#avdyU9nPC]K!0mv1&NJ3)HAfO2$M%qQvSʅKp1fag
hD{ ȜC1xPCsdG,=Bg"!;.eɹE*9%MwF_Q]u-a>CXb!w!V+gRaxS %QRG>/0',9wK8/3vq~	Z/>
+8k?גFaA8)5xK--zChUv\OIU`?|T)&P̒JM.ULJ./.],uWN376UYtxy{K*Q`6ŦA]l	wƬ^PK
yp65R"org/hamcrest/BaseDescription.classWkwG~Vky[חӸʱ	imJ@*$NSZRUR--p+V(RN9>po<3^kmEi{}DVZч>ₘI(VJ	k4TI<+4<*J_bO'E|IxFųIlWV|ϋ/
ׄ[ᚊ)h-%oLASf  >^MlxL3eRYΙNI|ĸW,
vLTpѼw,t,7R> i[uS08o^6˦]]84{R.QL_s93Q}Vyge\oP[N̜^c3{ΉK:z?'zC{-5o:WqX`ѩ`[.ژ~d`^!<:uFcEo܇T\C9Ypz
G	z{Woi(nh6Ƨʾ5OT"O|;SPCA=bm#ŒZCg-8<ʙХhXnKZC(ZFecs=xf\t0'lϼ^*E,jg'+U'o-6ֱ6tŐ3}j}=cs>^d_~(α+c?",浽] ub,"q\1Yc:~e:D\<`w$%0l<|q̅՜~>Wa~`_}%+V咎Bot/^S :FpPğ>1bp@{=<";;nTPoܚܸD)ӉeʋR^南MWܮZI<p\.i̺_[u]6lO`MB7&D̥ 3;{g[Uӧo-H0·Fsٲ^QΣ,RpDHe
w񽛅A>7q8̯a
焱\͒v@Q|3{#>Gg.#f'%B)b8 -eGe-Y-4ŰAVmQk8$ՍⰯN)[p]+ldEbKxuۍeh.eIkdh]D>*ބ.|Mo
]n&wn{ݔ=e]F#5tήtZB:1=D/:_;Џ;.Fa7]x{0]w2p13,(qeUofe(9_01F*kĴ'D]7ѽJuMr*&W\5x
RP"2(Hc;`6[UVz k@B m!H~*DP&B K"Re%
)l?_ܹʑ(J*
B()>"(|7 ޲L@;94O!&^DVP/!Sc]m5>~~0M1iFv!O£1fHHHOmk?Sƚobﳡo'hdM{] md{٘lYǰs;NjVJT!nrs\X<'<ZXzj}{
Ev(
!/.h4!~|NFP8x#h乞$	KCF0)kK^qdtlrm3r2r=Ch]psYryxeVl'YO5+Č9RPK
yp6[l5org/hamcrest/BaseMatcher.classRN1=d/T;t!aFG\. l'eP3tH+]i\~a@3{s9=;"r)İ:6,lZZb7b^K0,TnS:o,W=
e1ӑ>Cvû)q_\qt.1or^nyزsEWjTm[*޲ŃemjFKfw\څ!Jɚl+n|c=7;Re
y}K80I#vakrNK3v.C.GeHO1a5-r1=D0ЋR&;(=IH0K+`.S^	AmJjiLMIuN:{EiBn_"XdyPK
yp6iY~org/hamcrest/CoreMatchers.class][E[vmKK)^JjMj4h"hu	[Xt[yzwWxCxf	l̜ϙٳ0_5\gVs6_hl5hj0a&ؔ5fcHJ^Ue[ެ@{rtUc4-\nn(S2ʫks0m[nݒkVԼ㚋W6JZL&kzX [
E-K:;5Yr.X[U]Z)Fl[gbk#XcQm 4ZhQD(w=MXfw<H|T5EzΞfϰKCʑQ.sJǼADReLf<
.mtӊL+QucZi|hz5siRq
hhJ%П|&Bm7๴KtrOokycS`䜵HW;5K~o4oU]-S]kNcBe/ktB[zr[2[iDM2IG?ٌH{>lFxc7x&t?9~I^g#>H:Ot,aY` S*pNChyr\TK\pT3\r
XʳjVU!T4(LeyU(]%*=v:m$v`^[˸Bm7_Zٺ!ڞSL*Qzh
j|ǎ(2?MbT&1Vǎ	C^acR^La&2	2v4fI蒱310&dl:iHܞwc)[B[xW{umRK%Id슄4a߯cgIRiSR.cR%X}En٦nU;䯠q3L
T'{,!g#\m?$HNy<9~T~Lؼ*9+SȢJY
BBze!?v8&'qQ?õ%yqK{+PǛ%"(>^PK
yp6X)org/hamcrest/Description.class;o>CQvavFĂԼԊF=
IJDļt̼tkMt}̂ /d	YBPK
yp6n(|org/hamcrest/Factory.classOMK@}Smj/"xų')xچ!nfS_GI7"p`fx_q a!d+Di&&2WK2^J|k+kJ}Z\?B$4]I]?GUVC"j4?"w/N# \S&qa bbˠS.z5~PK
yp6	l!org/hamcrest/SelfDescribing.class;o>CNvvvF̤Ԑ|FY
t}\AIf~fPqp~iQr[fN*#ppjNDERf^^VbY"#4J@sRK@b`LlPK
yp6aWn$org/hamcrest/StringDescription.classSN@=C'N ,!4-]PB.,] T)-RAT<:@

%H{?'Z3w'%L`bZFa
fqʘSa=9^H¢n,	K	|m1$Jʱ)^~\%M,l3F3JennD*mľ[Uΐ*^&[MU^WMhg2%5(^m)q4K:pl3vc)(KzG8R!ȿX˳)͟.:*}Exa*_DOoJ0]\ZQ1(d`6x7EN,cV8qB+niL
VI醕:15*n8Vh]y..m+}+{ ôҋUG6U1p&1'.V4N>LS
{~#K".#f/vjwJ.*ӟbГXN.1`Lp)S7Pz^I@J4[Hi^Z#b4){_A'<8?T&OdC^<*PDjU|D;>@.|ػtL6uGt4r͐,sҡJ\"iA݂$1a	}O?MYn(nϐL*z-VBޣS1d=PK
yp6Э,oorg/hamcrest/core/AllOf.classVrT]DZ-[ii.%))ԗ.pM m(uҘȶYf'	/}:s֑Ūv`<}.{M|S1G9\F5>eƧdp%9⚊5|RsץB
̞vM'0Y`|kT:SU억cn1.E]gkV}RQ]O ]l]G!Wm?Qls4ݖ6KIw"0p똕Ng>1vGj_(/Q$6̖[-
4];'A	]y'2#^DN@mc5ʫݾkum/\@T@ʐiESr:ƀoXnGS``޳kVbWl2H֌Kq@Nˌ?:텱,Em=9;uwZ%'Dơ,h8W+XװM75|[`FدyȂa庠+
۸k
wpW"e+LDc.0f4k05`=M)'tm߹wNl6GNs77̡oգ:oeTI\'r81i8}+
FUq	~_ Yv׸K`)YyҤLP? ߑ19N	&i,wS6Nu[Bwd|+'$)ߐ8Ę!?`S7.$#RcÀ=sw
Hc1oR[-eC}^Ay~C\
zPS'S$~^$*o]#K?=߾}XeʹIE.QfPQJcaO<sq&y&Lbp=PK
yp6org/hamcrest/core/AnyOf.classV]sT=ױ-[ii>JRR6-ҦƤEvDDH2C~?W^x3?+9UKe`r\-R
[2~۾onYN/۶2EoOF8BMNKL?nssYLƉ0<?u=sՒPa4F[ËiXdž;>]
&
9W.+
>Ӱ{
>p4,
ބaS3i+
X$>޺Df`3y$>v3iݶ;&#\:)q&KYs\~G~JJ\w9$6<@̸!/'#5u5]I<0T+=ɬ6(35_ayV>/|J;/N94ɚο5ʢ-Ji_S\)M)=y3hV PK
yp6@;
#org/hamcrest/core/DescribedAs.classV[WU&	LHpK)-K`(%)Z'dh2LzW_|Er?Ɵ33&˙ٗoϯ!bQR@2a|n%Up|ap!\v/x"Ox=|&B[`bUKյT˲DV9Ub*kV VdK)1C@nS%̴R9teբ&[5|x*riܑ5fXL:&`QYj9e"M˖;S5JHǎ1) UckJ99_+ryS6T.GC(RvI0oj~Z=pdӃJ-j^A⾘}~^
.iƎ^<'(ŌV`0C}ld&vYlZa5ە_ofj̳8q26jVئjēyM-<6xKbS2
)ew1އioGo&k5CaK*ghO'3	o⺄!Kk4ICpc"
&0)#E	%XDYB]BO$0EXjؑ9v%{ǑI{IW\dICJ+xNv8}>iA8N
apy@su7AB"Z}$?%!\n8g/py=3sqǺ^򰔓Ԑ0%$f	"eLH72i&Sby1&LTnU7ws0K7<-u
{Ri;FҰ[Ze|ǻ;Rd=WAJ[s6|nw0tAyܰPK
yp6.9=org/hamcrest/core/Is.classkS@
4P"w-EҊ-0JGg
K	SLRFtFG?lK%gsnw7/Р~*ƃN+7Hհ2ЅS=~3en2=axѷm)ɡڶp
,0B-ϴ->q0\h̠H)&Zis)gOUc|U0Kj]zqEujp	#jgVDtMݚe\a7<9%Puh8QGaFngG#{!֖k^6T˹u6z`Clr{Z;/h4m
]!
5%
adh3Z֑.>{׿^
L6n8+UIC,mbi#}Denwhhn>ݔuPK
yp6fy$org/hamcrest/core/IsInstanceOf.class}S[OA,- `[/JŻDIH*$B6vٝO>H5g;7E,9a!  nq[Pd]AUU}+kޖeF {JXT+Odvb~G
ZQ;X%XwyuR-gLU$qIP]?p\G}c>bոr+':sUK^*QNIn bgMw3\3gZK3'lŐ9aů
yOZLpMS&ve(i/HM0kux.Ҏh!Vʽg込UjJgkqM~H	"BtyG2B~!rHV&	LRaMlf5'HOlzMR=3ݞٯltS|nP"e46[PXE!0`m\d|v,eʊW$5/4ifTs^v'92&1knz㆑7PK
yp6Corg/hamcrest/core/IsNot.classTkOP~
vUq7QTƦ9Ʉ-Lmel:"??h4in&}yos
`	[H
Bx#PsȆ0-,&Ojcn4mRł+mq0.L|,??x
%مB4Fa6Jw	ܳPK
yp6Фorg/hamcrest/core/IsNull.classTN@=[.~)kJAHH)}8V0rvE}}R_+:8NCmig={̙*6cK,㑌ŒWbDCi6C:+1HN`(qب
Wet
[dM0ȉEd>,PR?YZS70,\18jz/ 	%LNH2Dg-G".E"<63<%C_<gHއ6PK
yp6,dporg/hamcrest/core/IsSame.classuS]OP~VVڕ(CD2QD%*&ѻdlvFxƠ?e|O[F;~>~`thAEiyQϝiUCm
+`?x˝Nu{ 5Ã'I\v0_:Xo2(6eێx5资gVWH&liN%8}ugy=AiQ:U^)+@~OqàoyvK.J)M:a|qfd2SW{pǢH_
{ݮϦbN_z3p'ož:pِ.5VzGϖN}1B7܁g][^&aC1Py)ࡁ-l3uIxWX|i#}7v:[L_.;#K±F?F?$}r$
2B:F9HfH`dyz$AB54\XɺZT}>[f̗H[׌ywd>AU>C~r(OV<,9(90s2,rЎ1$12˅I([N0EJ3jXU"_17w#GpqHu!^ŸyoP
)oPK
yp6s^zorg/hamcrest/core/package.html=A Ｂ0TAH1"O͌Q2
@g30RQNV
`rpbT-eߣ~ѓ7PK
yp6;o)org/hamcrest/internal/ArrayIterator.class[OAӖn,V[.D"Toܴ!4i%'2ltJ/>h"H"~(mbCgv9;gs~	`	܋
WD917хI2=Lx#ݘ40cు']\J!Y#r)$ՌoQnN@ڗҜ:7"(G0ϡR4)D͐g{=i礍0x`!:Gq7PK
yp6@G/org/hamcrest/internal/SelfDescribingValue.classRMO@}$5q@j
@[ $kҏSb絳Ef9?	G!f4Rq؝ݙ=#Y(}yl&LlP8P0,N9wzoTWb[rKW
ddXN?0俅]BϷg\@##g>>z+z	?#1b)8m?TΔrX2]A4u=U:輭n
nȰQ2U.u'`
tӮ,I6e0O}g4'6lZuڗYJE ͐|%Ja9h4;6EnmYr~ߢ6\g뉡oZnMa{*]XN-z-J	ˋ$tj!Q1^SNجђJR9OܱH:6wzαM8C<9tG^WZR3ؕtylqY\e0-2ySu	)ޅ/!??9GV+q6h`$9
%zC
rHGet*d	Xu/J`Kd)C+K<EZMvc<ބ^֧ܴy'}eC,$>M릃L.OvJ¤!/$_M)?ϡWfЅ0EvU2i%h<-_rBnTgp.nF`oPK
yp6"eLorg/hamcrest/package.html5A0}~Q%np@	.HГeY.sJ!O3x=SL]$'OєX5KdCPF\3h[y'~Jk8,%!1AINo$؛Ԇ:M0!GvK}P^UL6DycWd2H6eΩ'6GB'`v4 .ث+PK
h<('d
"org/junit/Assert.classX	xT>f^^5 0h]BAbH%Nf,l EK.V[!֥ZPVm]VjV{}w޼y5ߗrs;/0X
,R5*I<exFgP>IsNQ9**Iŷ6ߡ2|Oq"ߧPC^R`D~xYWG2/̫
~JyQ:WTYoz}T}H
x/x]灿zodS//
p	wx߂ORpWP I{h"עUcc)bAª.3FԳ{IpHLǗe){8зH`4U?'0"ekG,F6'-Y=l*nEެe4FN
Ǖś#QJf^U면ckI]PM ۴mjE[hڊvvuꢝ\T4mEv-ErQѴmjE۸hN
uBlGø	c[Z[8OZ2-ho#Z$xL<VGSQQЃоXbx{	h-Z}Xu
b-A(}]ss>HN p.B$%`Yvt	L6d.8F`KGʭ`b2C3!5	Ğ-
`(-Ms|QimmƖ(PimZ82o ؛En2n*`ٖϪ]T&&vˈ2'WQ[
[^cvU(T೰j*n6(le;ƪ̵n.ۅ\NٲkUtX4lw	]a8Gփ0
z%uFDDqu9_Y#\e9|v#|7m"{`*Bb&yൄ${0
D%
2e־lrdKaKj+PnKj-N#2s&Zu݄زǰeaM<[SزB
ä5,nd+P0";^^ÆLS5Sb^S7S'ߏ9a}qsLˣhA8x1e'=nlĴ	bb-X.g!)!n5$S|w}X8mlۥC0(LeP+&K985wp7l3!-LwLi[w~)%/>ʻo%iAm8-mG 7C0۪}\L!^ah%)⵭mVRT*-r/.0wÁ,XƃKw/C^թf!g`uОU5Yͳeuqս\xyhI"Pذ4[*\+pw{$ZuAb测jꛯ:48F$myf4>qxp!`;p}w6H߇RCsچ#kh37BhL!i؊
߄i7.
EU,~ӑBf;g
Jg%@E
JXH~t-8jJ'՚梚QøH$^n-\VhnMݤa0zؽ±Atk.?50tgSTǟAAh^&Ef/~%0-H|V:ߊ`2|kzzQ֤xʎ9hcBQ!hyųy-^v#ƵO'1~
s0gb_&/Ѽ1ge1Uħӵ,0
C+ג	Xk}KEKDi]iDAq8pDf8P^XPRjwί _WkT#{%+ٱcا;}'xPK
h<Borg/junit/Assume.class}TkS@=KKCC<|
@RT:̈a)I&MP~'wmR;gϞss.ި@J)Th崊?=}cg(xsb9Rd"D*+R5ʞνBp%u<[B}RBI[0L4V*|ÁҔ[ltܳ组Ig/jXH?CI3Ɓg:6@cE$TI8"TMwƊ)WbJ@5t"੆E,)X
WpUU<k
^jb]AN^1Maڞܪve:S✫^c|?Q|}=8ɽr-(zj{"{ANtqZ]ZD;'hYTuI\EgfuCCaKh_i#5ujYB!TI7^*]}"k}C.Z42M}IQ[Ћ>y"%LO
uF`K4Pp	4~ jTUg
"(L:yj`0.KQL%%6>|EOD&'!II#!*Iq
#Tqu:ƙnI$!隙62`=|hц$&id-wPK
h`>?aOaGaWaH?:&.5T|Z!짵vvn/Dp|h3)G
:'t:G͗bP}v;NTGQdf7Qod7+0T.koON+dZr	GGBGz
Mu3>`lA_@-lPK
h?aWa[aGa@?X&FKN=ׄvTfj9t0UFYHQ]	ݹ$>xkTtގca%eA'|ly&E䊰<*jgBT^LgpԚl>$:+h՟EO %c}l47PK
he2؁yq7ܭئqs),eFQA{_"K`
.e,j4u+ӊE'
VvhDg5#W
2pRJ>\y	Pp0ҠFbQ(kPRdYzL|,wNu3]g.Pe,z}ҎHC-;.;骂JQi\v_a&¤Ys%(⤊8 zTb2~*
XR129c
^|d:-rMX*"8GQ^Ndb1ȀT}xҏfhUu^j1Z{TLkĜo)h--x]Yh)yBiˡΗZЬ1تۤҳ+ҠbZ=wӻEIra7jvߩwiyHgDG=tvD7X 	/)hv`Q'CxG{%sOG92}K} }>ֲ.@MQVn 8ɾv톟%ejUj5x ݠf
XpFAmIr9VyۢN?^0(.~DcfٍO*_C	(I\J	
u/[JdΟ9Nwoֆ`Ѣ9߄7"T쟠F?PK
h<>V!org/junit/ComparisonFailure.classS[OAݶtYbՊr٢>h4&)ZL.Yv4hG,%tܾXi~;v()s˽JfHa7o^Rj1h_0LO4Gm!
ET'uQ8rˎu%zk8
])TG"xcbM;":KLSy$]i
G3}}U%30,rc0b*xh3,\av:=
jRǒ!uͽXtE:mW\.3|*^7QzD=y-b$=}4Hn|3s}ktg̥|r1OT俋q@G|5dȗJZ$)IIvgP&5LM^p8-\5sLm1l`~L;b/h+7PK
hZքɦHl)Cٶ(]@uIܩU6f=T\x󿮷SE[<q."PK
h<^org/junit/Test$None.classmPN@MX6΃(!A	B
`_)Iw6|G!
W=?>a/D[>}NZ%LZ~
LlaоVZ7qFIzrZ>ϤM,ge9
g+zR9̢ҎsduW%ǩta"sy9]!@c0gB/tiݿ^/><kT'0nrHw[m^]63[ECPK
hQѬD	-,;33̼8@†M[u_Rx2)HKZ2b#jCFY`X)_KeiN\m;=#ԵVRG)U;,8O,=*q.k
j_G }GA\5Sؾ6#ene/u7`7I2Ld﹭a\\VƧ82hfxQ5Aόj7NfR`~ݸnrcG-,$/x~|c<ɉ8$)b-1e˜f`LU1a-"[K/V5cAX$M 	PK
h<&1org/junit/experimental/ParallelComputer$1$1.classSn1=NB6
Q(HH"lđ㍼ު>BU@Js:F!WH?q\݋)IQs3iEh	-
C2ұ&Cq$Đ`5ؓX0abi}Rp99QPi\5aCRO;&>Zh(ᚏ>*xC=`Oa뿅04/,8I6نU hlӥV])J24*zViuV9BYGtFOcM&:a)Vn}ArtJQJ5{Ep|BsF#T[TzkX O4| 5|s
5V:0Xcl?0˃P
!l\+R*Xpenl	+Oūy϶pha'c;雵];cHuTk{fb9nkŝu.m5'SAۦŁA_t]!}A35O̭Mަ1W#	!*ojfGŭUTfYm;zTEpj~\2K	nƎ+4%H"%ͩ9Xge~cH׽PZbVÇtQж̻ZAkjXұ:N~؛R$ƈ_`U[xvěSVu
k:`]Æ/.o=éc֬+[R/8%2w:Mى|bt)gڒFpRzaXS
U~km)xs(WUA\
1kƥٳ"$]j>}ST+x|Or?PK
h<=	-org/junit/experimental/ParallelComputer.classU[S@MD
Wp((VTEeBY!Lt?3bqxv
;9?|0{r
檊kULhPqYCY)vnm9۬Vy-C9+4LYe2H.-eΛ6ti/%YĒ*8jz'4]UeϴOL״mnRaPRҶd#M7tT-9H6.ӂ&ءP]@9klzK~OO͗f6˫e]ޜoy;PM(v-{7xՃ\7cj삎BSٮ&)#KZuW<)WU;P[1Ӡszl<^$EzZIV1ð_={9[w,Y֘`хCDBSv3hVNH2NvM`gY踃:Nᴎ1QJ,-Y&=8myu}w>\UYӫtk|ŷ^5fRX[F"G(FJiH0qfDD4f
GE}DZN/ G}19JcӒж,*l@$'>VZ%5b;tقXCbN89Gade(z8AI5:O"Gjzm3:CaI)0CyImvԋ3$ى8)}H^
al)J»z@
{C:5$jD.wI&pCzw]FPK
h<32Aorg/junit/experimental/categories/Categories$CategoryFilter.classVkWg~6U *+H^i1Hୗ%Y`/J{N
Iww\=ygwޙ?80v`V'pǩ0j0i6aÛlxIF#	c3:L#ņ4fؐ,d6zذ(
h\Zfe6_Z\ĻlxO`IǸJt} ^OD@Kb!3|aC01__	x#[{G)?G?gme^ϋ;sDYժYI-/YU̽#s׫ʇL!QMHfr蒣+<1KEB)R27&-6HVHU{S\]G־CY50	Zt"Nn!H< |[`56g	G
I&S:hv%"WEs2Qg BƁ4NSSXVy^`C`iUe;DxDs\yhK#se(L.jN.r`nG
07npꮑ4s'ֵ:7rXp[ib9DlJnd"`i.Qgl1N~LPX^]/4=8H\auc&nh#}>xMn0uiM[(@z\}hGڇ6Zc#gl<]pY✣2kзSvP2&=a"F RA'缕#5DRUsD5z)]Y(AKۦ1{G('/Н.EJƋz^F]/C$Uޛr(^"?A7BoO3{ɶ8[*!3||8vzMHG׉)ieǨ,;:);DiDW0U(OK5e-ϭ/3=4tikg3լ!Oo;	Aw
%vi,j/iJ)^ɹу823}+bAtz50s~LJKg,PFeJX]f!qgLqRŀu4ZPK
h<! Borg/junit/experimental/categories/Categories$IncludeCategory.classJ@ƿ1jU)*"HQToI6žExv3߰oNcG[>R$P4ʦgTQ
}Zʜy{xPK,@
w9ɮ P -04CQf[JG|@@9MG}7/ʸw
]9l?c˚iZwK.&?/nFB.CIFsk/sj
QGhj/+>SЇqWJtПzm"\ar$គ	L*'rZd\ݡ4J=Ţ'\yFmWmhTo+R!LE9VCoQk.k蕯UV@ͱx"Cb_^	=_檨	__.h`+YߎaE.;)"Dhʴ*Shk-5ͺ(bl PK
h</:org/junit/experimental/max/CouldNotReadCoreException.classQ=OA}pAXx116SͅB~
,9vޞL,(a-fvμ2>VUFHDܗ6QF?\P
NЮ/TIF즳P̐+rD%q0M=9ID"MI1
W;6f7k	rMW
pƏo(yoE%WF5F:8{G/缧*OsZ.6PfUgPK
h=y:H%n̹dXoٙYLLD|*R	UW+RZİoޏ߹חIC?Xͦm
|tsM):v|bR;_xFXOb(==œIkhhb\6%%$URvPPW	fn1?"$|MckehL[̰oC(}Đ`F:f#
BB;{+*\MZky-Z=a- GmGkX'ma|wv=l~n\5,bPK
h<FF*org/junit/experimental/max/MaxCore$1.classS[OAJkEEV
1_L0HHxs(cY$*L$$Q3z	`\9s_h̻n`<0zF&>O*&SJ}eV&Q,SaȴkӍv3%m$=,O?VA[$13<cpZomPޖ0|+!O6n?.@0+.vT0~E!Ot]%`0&4QIBjl
uf:t%6:N
,XBb
!.(0L*yLFΞfKeQSĞ6WƉ<&H2Z{`hZul,_^:&l\յa$>UsV;Fw-K\܆{Hn!pڹL'\7#ԏ艗h#"`Яp
n`;;A~ξb	#;O0ǘ8N:ҊM^:+SZ7|L7q<%xWiU&O?PK
hMY;
߭=ޫ}*x͇C,p+o,~~@yS]Vaps:܋
>O( 8iY1
T0;>bRтY*xLE7Y~OE;y2PSK*'|EW5uCRmLJ|W`qm}=[ϻwuvmX{~Hmu:'zWVW23,5-f͠#iבn3afFwր;n0dTo-:$-Vh4/;x7iw%3X羨c}*wX2޺@.2*nIHv1:d&\D2ݚmgX-u)ݢ
KK
$fT'3VA@sK};+aub|O.`hx5~a+S#
?O4tq.İg~'5~xiP~4O}F#Z KJ5ՐDB0Of3k
~?jgo%.5~
ųt͒pj[Y#TM݈
6{M{$"~$QlU)
YFtϖ$`nKM'7tE1-3l?]q~;ze9G
0=N6uNEє?74y͗6l2Nid	-:Z=2~NSȮ ?ۺ66zVpISQRegDX7|Cm(D&rp>O9bK?KzbbKa,W*=#%u\{J*y>Sa;9(ݢAeM6PƁ]Se/rP‡NUX.Zs4rD߳Y$Ď8&P=&wҳV%9OZ}L?7k]j
LZkU(Pv\$שslQ͵	(SROIl;Kb%=O=%jj2ʸpm*PTp)i̗BRT7,{$vCbV1NyU¡Ϣ>p5Yɢ1YڶfAg}F`Nصs,l}'BMXus{\&0?GS "&@t4g;n1Jrd:3	y2I'5N$
X@6B޶8QI䵾p7EGqJ.:ғ`6:~r|1gb
X$р%HÖ7x7Ht	Ldykq7]\)PQ0ӎBl	:1t}ڨPK
h7["IETKsfidRMo۪3GdNБ9E{r_4^J$JɛI$ơvmLPZa/#2">yS$	-(kFMQ)!s7~d41>G	><9F(9ɑc>lL}
q[p
8I	՛`Ҫ	D5KGj
>dхrFiY,GؒdPK
hGe:org/junit/experimental/max/MaxHistory$TestComparator.classTISAz2dH
$Q\APUCldhK͛ZhyY史|=
0ί߾cR|
8`g9qArI2a#20ļW[EnyUemR_7\vVɐAFTosQ.gh.+ܙMi)%ݜCeTŰgި]Y	Ψ.'C1ȥ@"A8
-9Ƣgdn'NSRޘnpnU֊U&ܮKm_%opMr(6e\eLeu[3g{A^9Lʌ;%>fk^<%TEf$隌Q\Wq2T	t)[(2tƩ3ORжST:K˞`Sؿ6
$pfm־L#!
>B8d>$E%=ssh~r	=`ɤ(!+ m+I$I+gH/|$IB1ajpVЎ@!('H5DߢAZB*DW3/hdiYCl-hT&jф'S3{^d?ԁI"DLz{m!{d'_Pco	_"W7kWm
8y=WސYD&J54*p	GeCBDL\*b#db.@8<-)"t=iGPK
h<+org/junit/experimental/max/MaxHistory.classViW֢i$1$$0<(ւ%,+aĀPp$LZ=9;w;xxK>D__za4 N8z}V7#+*:rȈcAho	4yiexQ5d :4Њ덜Siix@0I3is<߄4Ѕ_IEi^8^nuohsq7|_N)?psguBTnVy3?j>|u.jF44XN0me?M17' }ɱmhMNih+{JknrSDqlde4bsC%cVnDs]dC譅Jx\of$֞QכO];vRK7ʦr[R7fe;j,/ZMYYF4E(Ѡalf
&`gjA9[0<ڢ449
w3&C#voLrfP	5Fvm&pZCKtӌ4lUEVٻ*2pu}9%Л(SO{v!ʽC«xڸs8G$ZdlL]
RLRW#QLi-aKX=9n`;5wVn
*N,Y۷h
+VՐLlr5KaLy/’VO11q6eb?Ugm-p`S1+q23{;6R4?gy`8c&y'5t_J\ M?/&q{-"&>&>ؔL*7~BTUKqrpj~e?Y8n`x5eI8O/)D)JCFeU'[	,{ڐCw*bY/	S=t֜bkفZhKN.ϕ-\ĕQF3o578U1]$Ey=QHIɹsM4]_Uf͹ŏP\;.gWzHT &>뙿MOsQK+7y5 7FD=.@I.c
|m$iNDs8lA3hi_3ໜK<r&#YA+h9751~2mouN@G-z׉w-QXq!Fᰟ
qlgx-dM?У2p?1q^qV=ORSaFIYna1aY0aqDqb
Zgqh+lO;>t<!ldKUQ
y)|k
vάc&/XF2_{»(]D`I]*Q펨ZV|	LFi?/X>{Y֪S^5iO6HzB7-RM˲^L
L7/k_y⧬6Z	:0W!$%021lAdzUG8v08"ňUO4j87kqN$ǀ[?!d;{w}@0IT+bS\_djIw:#Y~F@iD9&8&NYfG)t)yr1N)BO%ym"ڞ[

BZ᪹oPK
h<{|4org/junit/experimental/results/PrintableResult.classUSU.IdY#bVLDhk,P4ge.{)M(Q3r22/dY}b`ħmc(cbb]^lė7@M`ԗA5oۡ퇮+}{-2L-+ڶciWZN}ՎtӲW$od7d=5Φ.0Uֆ+eZ!fA<apBl]5]G>ARaf"p6jղk*Х
^?p橣ZtV>=Y`yHU>Cr\+q'Μҥܱ#.8Y2ګkJɾ>TڗΎت<Ξ}[
nVR4\
q-YUpzC
,^,cA/^I|ͻ"/X"l,l[Yh&M]Try1?᭠bS;?"3Ic}=p\]g=[_i2zBJ5x&,!0֔ڽwS&5t5zѫ-0M(YHKOo(1.F@6Ve\FI:$ci.tjHT/fd$0Lxv"G1{|.+Џfd櫒&a"2B11?K1{lf͌
$N%9_!H<""pL\f9\y	|c6Z&|m:/LqS/[B7_c'nnfBv+81-s7l'ޏPPK
hg( 9s3o?iݘЃT?R!̉y^BXb'nw' fLѬ2t,i0bMz4?Wʫ$-;oOp*9kmsoVY٫[5niUn8Xܮ뎭tm)Ve̓kREK+0s	Z$GYwjfiggD0zakΩ\?dXϹFat
90׮.`lkOW]5/69s{tI9lNݢk1HdndMָKRޭ̺U䛚Q9lEݴ5͝Y
bI2VdOFO9dV(uՎxU1Q|]U)<[FAlcO@%j/2(mC2̶gB̈%=e+DMw7JdbLω@_r̦a v |h:1RuoOn͂gQG=Xo(ZA?Z-G?@J}K|SQv1*høGxK=P}@R`
#!Z7
ɇW'hUBI?Dxx]ꚢFHQ–p-vmٹs̟?XFyBCFE9ySb$!7XV@
ϭwM0^\ЫY!fڦ_d_e`xj5KH8.wM~m-yN+rp͖}nw})\oa)p
{S_~$w/ZER.<5kba˄eC_emt0#Uas?p)Jb{"`xR}n\u[LDFdTa9Ug[M`UC)e)o7.8 Kg'yWDR_h5DRta/j15;D+b1A:~Q*&1%0F;} eb\Er5Y3\\K|?"1t&;5PDG>Nqʄ|4qwFГZ$PK
h<-3org/junit/experimental/results/ResultMatchers.classTn@}['qcB[@BAIhkBrT)"(R%.u6rlUNE |bЦ {o3c;j,X㑉TLT-dĮS=ed0ʕCW/·j'px3
b;AØlHP؋&/yDNba\I$|'PByX_BI>&Ro	ɶ؏,F16ËY+QpՕzrg?rkw#9TЭDbhTu(4uJtJнByn8z.Ѿ\5
[4sN4maJ	칅iӹi{s1V&[C #}i}awRz<,ӻ3%Zs
i-nckΌ/X8_r\(ԕ1A4
qӉwcdSPM
^?Bȿ?MBBBt?HLDRFREWjPK
h-org/junit/experimental/runners/Enclosed.classRN@=j"ظư
]a0)eJr?2ނ6{Ν8f^^b<Lh`2ȞT22TK~m+>pWjvːm*%owp>Rj0![Jݦgg浸ZFݙ
:g(}k n{BˮPw?]aH_Er1FsasH?u>7+W)\-t_c'a]PK
h
G5H4e':l;8	֥\j9ϒFk+^2ahLv00Ds*ØRaĬGJNL¸͜ESca(F%,EhN<ti1yF=ۂ|^yIYҙyCYq=鑜^,V|؜mC=TiBI/|Q
JzrKl;v$*vXƩ)'L!^Z(egb#,ycIÚO(2znbsҚ+{R0}8tzv!oy2|IϥK3F2bnmX.cu#!}%k!S*XU[2uݫPCƦj*V-ȫc<1ɼhPLD݉h1&5\74ijj!{(Hxsu,GE1IΫAV[ICC#=?IY
ۼ!,f\9
_jJ(XSr,^+}ly=Jժ:yQԧg	؁Z"ʨU[|
EqT:Ҭ+a?R/vu1N]ZW`s5+j`
Bs	*^Jk~4MkK̿4993c
ͼJ[){EHKPkrGmPGzHm5%m[a_嫰Ve&op!,.c+ZOP'|{aCW'}h^BYrRe`l\K66P-$iUډ-]Bn.m59ZC(1({a5y-ޟHM'D~pdH[n#	D	Iކa):)F*Hk܃5pۜZלGJcjv5cT+;{8ڋ1I3Njg{Ł{)c!t9FB4vvV	UٙlCNĝv"bIk[?]tt:|	bYp9
g
OQSIH;tfȌ`i"
^D[9rE\gBHMc*hDʅA@7lh=7%/""~CDždz	
Е;
.TB %F	'A&Z7S-|cP>EvDl8|#CL;Qzq06-fg|3;`68jı@8љvS`F:ޫذҏD-u!p6+ IOzMSF%VS!Ukrd~1{x&Ĝ`N3弥0ZG%FFpnd:;V2WE2=,f\E\}:F^5QY*o%.8C?<56H-nBT&۰ClB+堪=d[y/PK
hxfB,9u~@
2plqFfwel9^X0C~]}Mg(z6>MHO'җ)Vy>Ru#\Cp<=x^'”Ȑ+Aa(H򸡂;{W@PViH=CT39nZ:{pGZ*?P%Vg	:svAW&9*ÁTH,sA8KUhoX-hj0<\nou5zJGEԃi6g`Rqlf;YYdFɲ|;E0T9Mz6=D>oП:MeЬ贇UO;HT!@}(Dt7иt3t+9NOQ$i]I47Vb*IC8eea5"'3$Gl*$`>ll#PK
h<컳yDTXorg/junit/experimental/theories/PotentialAssignment$CouldNotGenerateValueException.classQ=KA}\r$&? XX*DB7ɐl=߲,(qba!ov0oUFk>6|l
,JF=2u) nIz2J3;I`4uiGf9"=7VV`'4I4wCb(3hxJKs!ݶG$a3xJ(pc2"qa鴼ɩ@$U:Z|P)GI=
'.r|YY>D3A笥XHUʢXqLerX
JPK
h<
;9org/junit/experimental/theories/PotentialAssignment.classS]kA=lZ֯bbROPŖ4^63evg铠GwK dvf=s3~	`#4p7Fq?)=ސ&+dVЫӄ2Z` yN@
Ի@00$2TgM"ʟ`s<Ɠb:=&bwD*qDETt_Rp"OdI*Eލ'~oFr3v0%W)\.BD3kوe<2Yh6ʛ~槾h	mD3omo	,P/;eQ/iW ƃ]uoF	2VxmcW*]FxlOe,%3:Zʈk
ƭWҚ[#\y伃592sjPK
h`Gv8OLĵ|8?"	w.\=CWU9۸PK
h/*qB!j\
˷!sNLLt$W)8&Zy9bA/Ó}2M[S^ Vք-b}z]"v=)55b@0V4L`j!b)$V5<7
iXc
;kx

0DaHF4ȸ4Tr`W@q$*\Fȏ_ɇ=/QxKtA.C_I,.2{de,8GҒ1iFFILR]D|ot?G=J-54zu|q:RG&MŐ?'
WP'?d0E;FOXEb۠ؔ0na(f100.aRS	SjD4+kp3L,;lMU.7]P,l;n6p=c3q7km1.y䶣-n(ƻJB͝鸪MmuOU(o7Ő՝Ȑ:iaaԲMKBGP;7:."qf>1ůx]
Ll!)&TcMu^bE 0ȈHw]2	35WE¨xh~_..v&l|&5!r̐%Uؾjm/"u}VRMͰc.9fe4E:Q/2Z#^JHx9XN3aוتKzP/R~'B4_uͮ	4>F+|u_xQ!qôa`c7unEv&_bD7be(Ҹ=kJjW7iDbQ+yG3D+' ~`@At@Уԃ֤UZqhVmT
ۂP}ɴQ|}e܎t}(4V7zJxں㧄z
3H):hP~` ڒϨҗ/~"zr"J1z=+̏!ч:OϿbOPPK
h<;'x;org/junit/experimental/theories/Theories$TheoryAnchor.classW{f!GVGKα:m:6]Y.#%M3dcejHrcl{f*-,Nv`0$˲*Cxa1<ɗD|焟'"4|/9~y_%|YD'EnW|U<ǹ&܈o؉|Sķ|ʧӊe)fL>Y#=bSɳy]f^JNEK2k\<ڱ,OD,1aYyFNmUKMt-.ySa8T@@]֒٪T
M}si98HDxfk$Ca:dX3h~b3iY;)*J>Kbt0uwdPSVtܴ9Xɔ
~N{lK;cg9BS,bSя%jg).n"þ؊l"(	dtN#A͖7۝+3l:QeOCj@qAT}~ ͞5%\",[4i-l/Uŷ=-M֧ϜU53nSxAY5i*Eܲe=@ 
EV3Rٳaj{aVM%gY}7MޑXT4fylc>x.t1QbXᦅJvsqo+tCs/3T>W=ŅK&1%nI؅$4	MS>*	{q>얰~$Ǹ"0*'aeT2{6U}P^2
ʌbF'#ҊYَZT-֤dȈ~[bG%y$,^¢KpT	7ܔ
~.~?רM똙~rj(9k	<쿕;)>-s{	\meSLWgpHqfY[
o).oX*-Tҩ;)sOaYNieDT&5j=6C N&A+v}]o!xSmZ3ThȚvB#c+8j\Nɀޠ:@?ۆ{D 'VMHkK.M@vRV5H*Bg∰sTm-,X]~BF;!ZOWI&ΣG]\obݹ^S(QD}UWʪGf	`k_[5c%bTI+a-r:JbYVw2}EXUTBWA}5؎hD(څ8Pr''/@gVnu?
l/!0"&<!G83QRx?Z08C'u8A29CdP	yߚ/劯9L9%8T!*ά*?ND!r
R",b5umH(kX_<AVxH@m~'og	`C
s%
=7URS2QeC2e|e[.oz6g6xKWɂNRlE0qR8J	lH/ExoQ)'ܪUӱΉ8O@)^[Jf,st:pW'`E*CǂW3)*i;&=tU\RQעh
9(<㴧ሗWL:nTWՀA-bx2xa:MܸEH!g'B}
!NegdBiϏN?]@t$^GSer-pP_:ܠbMTR%;=hdYjFW>#	GhTUzh+pmU
JY*N2Ej
VYC.UEơ[aj^!Xo}
4n6pvPK
h>x?gj	_UWW_qp‹xQ/N㴌'xOz1ᅂ39ƛZ&x1qaO`!-#)cڋfیI	E^8C6ESI+"z4~Uه+U.VW\2^S:ޠc囌7\;2Uާ0RΣTٖfHjzTXz39~'
>G
>%'LQ	.Oe|s\V;|d||;\׷8Kذ*5{\U?⚂p]ϸ.abܺ""!Y:rXۜbvKh[yuqa3N/'Fr_#em9E,jt절%2Wj\`)2v|m&QsS+fTd_Rl.P%쥪
tqPA:HgCd0@ˍT*l3MKO7_RXM'aFܜ>3h
-SI:^%Gbjb@,
ʠ YGc1(˞%7]v.
D4.-qsZt:5vݝha?<KGhp~o-8!qEG9huexZf!FT9i:&6!h`3}JJBs QۈvѼ;*NZQ f^sF<@FWa_ΰfo_?K9֚+w
;\;zvԻvzNpE;i4/'~>FOkˠq~M5j0@T8 Qv^֎1Y;.v]bU.UJ_aG8%!_=/JɍPK
h<
^'Pq,org/junit/experimental/theories/Theory.classP=KA}K>c'vA!8yN	ñs>`;'mHDIe27yf_
Ԅ,`^Tffq͕%TƁ]NQLGzkzrqu&_U	_\JUgR?9	fVp{^kڄ6:2ɔL
.
tIm/PK
hiWJ낑j2WnD熽9DmU<2K/	 7"WV0}ДR]Qs	_o@Vorg/junit/experimental/theories/internal/AllMembersSupplier$MethodParameterValue.classUkOG=cSq0
݂KlfqҦMHBʡ(DHQ>-=޵AH6H|zfץJ?̝;91F0?Hnf𕁯
|kNw
,Wk
,	ʨ7
?hY;"+=OҵV#_n
]S=^9UuK``[
-Khwlw^Q[㩃
[;de1wkeCIԳ>"r+Ց^dVԖ~dh)5KT͸u'8vdo'Kz+Ǝg[wFpܷ溲eKA+֌;)#t0M􁞷NC":J4GmFZG={ΕzRƠ78pq8膎qLaQ	J^(+^D}cq"ټk=cӕ^+j*4tveSy"`VqY״(<4mT)	‹qZ7E&vyُ=
;Iq00k`M`C@zيkg7#wjO?
ܩ0^WLTg`lsD?aTJ{DEVp.[2qYS*&q:$Uz)|='iȊx4~b4qOCy|T&b8%$}B>Ƨ0Ƨ
cm#>!|Q$8Έ_V_
kaqVCoo+-aۆi#Ɯdg1TH
=;?M/ft|IV|$S;M2t)	A]$*XcF_f[T8ú5ޘIcvnL7lOޘḦ6}I鶬^CMdR)4!dJ(5<瀓q
J. 4`ںq#q=L+c=j(O
.Eͳ(DA|uŠЋ0{v.H1u;M[mE
(xcdo~3QEFdBkKG\@*K!i_tYl1&9"5f
jiZF{R(PԮ*f.WgLWŒ[gm$8"&
g#1%8I2tknc6yIY謍CuCP&%ۄBTy2h./+WTK[[J89,Q肰52q1aY(ua#噎M;J
g3m*~nGPޤbC
bvNᜊxZ3jozhK,@sp?Ԑ7h@ݴ*pW5X
0XOS
?Uix?W
/E+ZopMo;
5TA񒊗5	f,f}J<7Cb7Ni;.i)1qO/}1k- d{D֏ȈGE7{cq숓V' Xʟbjq
BHFt;bںe2̑\븅)h\سVNT
vy~qmH輛D d^6CѦWr|uLO(&ZOVbB^mǝ̭Z~Ot-[_EV/v-:sg)98p>M^5c蔀Jآѣ\ȥΪ9()M7,ku&	(*y}b(?0@oeA9V8-\.!q'Bj(f	e_LA:PUxTT@yi~/Y9Bj=jXva-\6s)YVZXܪ?UYTNcYg|zk	oZ6P6spKRk;k
a{+ъx]I)SiǜO/QО}ךiKkާ@s5@}0)Դ\F݁25qŞBH|Hu1*܊A3$zEz\6@+	pK-Qp+M/cH&Q79wU0HfQھ+ۃk
nibA1}U\f)la9ZilmlwLAUKZ$u
>LO x+n荎6&RIZn)=ə@m}hc*T8p(w딸
*dDfd9Hr(_+F}.iQ-/g^r-x5^|I̮Zx=/9o$ЍU|-o[
Gm[_0stэn;Cܞ^)Xɼ>W0u']\,}I3vkvd!E=4Bf{q3VfIs4N̏U/`LSR>SH&>a
a5^߬
&uS.,i̜֩AJd>1f3.1,TvpKsu(-0^)*mm6m;2Lg1Җ6ohY'=9ܶ u}\ؕ`:.ZhğՖ=o1|k/-poYv	8ػ\Jpcx
z
o+KW%59Y (의8|'d<*l*:dEWDl' f>7:JtY
s`blək}QIAOhP/ѪZDf8ZdCAX!c%:V!Qk Mws)}q/zHc0AfkԳeGjkCC5$1}ohGfJT#%e@7
=Tl?U;L#$x{I:)´Lqߨq MiIOKoG?ӄ<*s8YRy{@BFTnE7]%Mgv12g雽ӓ\'l/ꠈw'{_qݫxR!JaU칇Hwgh
hki`~Q"
%av})/ŀ{.z9v܃mN
T>*/}
̃o
`7؍Cռf';oaQB['mGdn"LbM{UW&VTx+utTf3UڽK^\F+^e_}y.i"Ty;OdhgIpE֜?PK
h<DQC	Jorg/junit/experimental/theories/internal/ParameterizedAssertionError.classU]WUݗLBS@,MUhWTR>,5|P*ׄLL:3Aꛏ/>ouIWZ{ν9/xXTr(a%aܗO蒏{F5i[WO{l|lI#L>E
vU/6n;e>\Yz,q5Ҫ
Kd+ھjf)Yo|U9e̹afvO}ϝ.X]/kZM	 Z{$mc-rֲKJAkjմ[-НamҲZMN/d2%۶u5K{z]}l&Ke(*V{0Ď@W^
V,n%^NV?v^5jiYQM/X*q(?T\&/k	
|X<Ei
-ЋE~\IߘŸCS#9djnfW^i(0W~DsVӗ
)@?
cNb̙`s!ЕH㦂/U|*^*4UL"`OE䢢2ߠb5a^	KE	Z-xQcZDGk\=	aD9gXEˮiT&yᮟ9>
Nn\Idl[{~	iNpj,qqz+4b2ր_鑂ѮhnSb¿bJYsּN&N-^͂@G)w[o9bW9(=+uZⴔ h2&Cv SMsMtO>C詷JMQ8u$٣,vyzOMA	'
uzW's	L|أcW$ß+u+B0aj ôI(ɜ-ΘZ'i(tf{dÜ>> >nwf8囥oΓwgC[U[z51p
z*|%.rHXG}W!ƀBQjvF={Ѕ.ӎcVGIOS̳QyMAWCN@mLfך'׷gNQeR)1sFge$oNI9sʢޟ*\KQwƨϞ`U3a6>PK
hIgDsMhg*ḟQ[,#OXZ0R2d{eTPI(XIe!,GzXZFU
.Gr3(U5SDEbH
dJWfQa3VގM@یUǶݽӡ&pLEEjX+\*Sbvt0оr8|=5
Cnq;;bc=swy	b.=k61MYAjUhѭAE6"k޺F,Ni>""-np45(NٲU,KXБ
hөJɨu]6hY2xƘzJ;oi:ƐyFۈnf*w=H,,ػ;xh{`fl'(#:}u銰	t:UE(eh8RaM^4͹SԷtgy6ݹTweɜUXA+h'G9{g;rtfd(v
A^
Dg)5J4 GzGя!q=8LUd#M#oy8I;p;xFUi撬PK
h<䇙@/org/junit/internal/ArrayComparisonFailure.classTmS[U~nIIZ[!	%oR(55JZ+!9	
sM_WT'?OQs"0cfgw{_D-9s]#XS܋K=cΈ1|h.=XƊ>2Xa~
Z
e@׽GE@BBEYk.~B V{e]RC[6B]ttՓaWcn5Uy/TUfrqY2$ye-W=ZYCu}5=ܘ8rz`>U,OV(7jzH2D}	75~5`֬f;'kyߗ,ԷwԽ%k9ۯz*^Y='yWˋz[yf0aˊWUOMD$r"J6:U"<ςdhq6VV1-BXo]1ZԒ6ݎҔArgZg3lq5b.;.s.O)W
*±Tc2S5E1(9(PD1[uҕcn	$O[%	35ycV+	;/{`$onlR3QzRvEE0MAVXdU=K[TBQSCNiOuy"&7Ͽ@UB&(ަ!kWטܷaHTa'Z|GGwqLEbdЮ
AGF&(|FլS27:27hs-PK
hEy۵["mګJs+oזZv*`:wZkn
zqMCEmIߵⴷ֠ts}<ۚaM˶P\fn*:[/η|ۭO<Ź*+>T})ae;m_M5oٞ[}!4hZVU2MVEk?+fӪg;AĻꒊH*}tDNE6$a70>/	 @rZ]S輐A=ʰvvvm
~ʎ\nT)LyW䌭eSZ&P0c&@)m|jbgu6>7&ΘxF_!LXX6q%kb
	[t鯭fm;6VY0=&S	Nfjjҗ|kv,B^cCk]6=Q]hH=^3yXhy!K`8]p]‘lo~fZddfU#z[3ЁAmIO{X#ڳ.Q6=];2}Gu(3kGE9y*r݄x@bGq(Eeqy?B{:F!	-`R&hd<%v>{xI/MHl\JOرl)'iog*8wcs1My}Lb\B5qbw'z؏0491[x
8kfEj籂Pr^4sb/wk"T 	*+|;VIXTUܡ1In<ȸSk4%?!>.IL)J#%[URKx}`wB9a5
|D&9Kbsݠ[PK
h<.$org/junit/internal/JUnitSystem.classM
@Dg5&;;A!h%\H༈G+1|Xa` %D|7A,guYM+YkBZΗ1
f5x\˾OX8_dFdh[å2<!BHzPK
h<_SM#org/junit/internal/RealSystem.class}PMO@BVAP7ƳLFR7MiWE2*/oޛ73ݏϷw{hȡf"M[::SC2hd(Yʓgd$+1rX-ܡT<ު)C1w"e	_JӢW!A؉	듫_t-G	|~ yg߷A璸lᬔlsdXIdˬIxDyy^2{L _lǗe
_j5_PسBd`ҰJe61`;U
("RXUZϖӯeGfpƴ/~ӘXf*0N;s)@$2CLbݡ–}Ӕ;RX !ᩲWؾeLwM`z
7dɰrLe/gVtNYp%2w
육Q;XsfA|`§m5
t3d"lr`z^\
#g&vl_db|UI˶f4)=r%B -x|\M?=;tJa-׹lH"GLgCQJ;1	x8&+hX{C/a&qn
}t.ĜHug*W&τZ.o `[NB?mp)f|p70pM=l7Dq|l@N|R9YS|t:+`+l  A#Rف,SwsƳ,y7Уmb/!A/-'lOq
nY%WqwH/v*\ARxGپxbv_jUt^߿% ,gdl.6KeԞglE2
(cS~64>j-;W#"HOӴfgyiT3
94浿mܾtyYv,p8֜;AZ+)ebq'G[}/DsYKxjP6uk(
5܀u ,)6^nA!ϐK[Z*p*o!|Ck\G	5PK
h>>PJx0kS.!e\nJHJ.$r!Y
O_սy2!$dEKGY*&iREcy2䋶	I1,Ow,T*uWY4e}WCuawCnn	nYS%SsiLq_FSLS||mۆŒ6FUk]&`-!2pH3Le<=C]\bG	aH!
ףՑ}(ÝP==ö\sس4vJW~2}W_6`d{mMm'5˲=wW_A(	JaLc=!md3ݩ%vݩR[3͋$<>qo2ܑ{2Ǣ9xE|!K|%P+ؑcWj2\Xj?ONxKCeP^i6-c8ݺi5qއ8SQ7jn*zգ+S5Ԃ]QdOncn-Xܒѫ!Xd	ڮѿs>/BvcIPtӗHqƷhV@),wGYoӘ=!a^C]&Tz1+d1"(/ùԲ@"#$j9JBT"⫓/!1^b.҇sBZxSstwDӑ|'y`h(iTIeI/bGJ"!&0!mc
B8
4fIwinট[4.w4d4c>?a0x+OPDjJ,Hħ;MjmNk'zC!ΒLU&[m,]z_PK
h<`4]	2org/junit/internal/builders/AnnotatedBuilder.classVYWF
$"& ąljR'i{@8ZH_EiI6O}	f_>w2Y'qO´	3	D1+澄9\2@BN—vQKx$c	e+	Ws|i$V(~P,sP\_cH.fֶVڞaٖ閷>V7<7M0L,ζ[9eqj&7b;RY2wI3rd`Y6,kY7L.+;Xו1jS-㎥F-to6{Scîm'g.%Lpfm SN^=-Ab>5Së(_!8v63'2/P{"+a:)ۖhm Dy8g~;	bEvڞzc-yW+ܫڛ
93z
F̪(Ir
_4Ķ<\S"!\Uv[A
FQ-Lљ?шhL{x(XS+gt0i&|2C,%RiDZzvM
]Պ[}sS\=4*jE7_lG}I	T@g
`[Ӌ=C&)qtmsoeLv45͉֚Qt:ٟJrtS\0Ýs8|ˤ-Z(ȹ4?\jeX+RWZv7.-۩ýT{[7^}00%U/hHnhHkLD~
ӳ|A1Ir0
JY&"r$ۏ!bo]=8D;ZeT@$NP='JaFT(AILV!MhK&9FIc};H	T:%Zt$o8g
k9Ft
xݧȑttO@O9ɉ5|]Z%Yn&U"ϑ}hdÇ'F+M gA.ImR;I$HPK
h<D2p0org/junit/internal/builders/IgnoredBuilder.classR]KA=l]O8|SBC->NaYglʾTh}*s9̹w?F<O<Q}m; T6q:P6]~S%\Y}t~?,Vݙ;yBB:(I=B({Df9HEQGE`SRo1	V|ۜީteec&syϵv,zyK$:9x
2N7h1ro34OC:<_]a,L1t[sAG*1r,DEDleU[2&¼PCeXo2'ҍ-@
Z+x4VKLmD-Mg0Zأˉ6XؖyZp#4T`<~25ݧ!IP$=ekyG@(UDIPf4ࡼP	$>BnJ){fsΜ_lt`ᖅeyܶp]Xg>Cq]2`;v+]x>e;\IϒhOjV7TCo?&!OP~,]5?Ok%PP}Zy0Z/Ŵ{#Zb2:tpdzs a-I[Ŋ(ޔ5;G-%#uqU鋳j :2=4p\\U39D;f
N8{ms-,4]n/aery몧07XH2\ZQm_s\+9iJ(8*$bȜ0GXm!ߴQ8bGI'#U"	UHHRZ&iLE5XJ]n"c`(ȖqbrwY5'э?PK
h<	{Փ/org/junit/internal/builders/JUnit4Builder.classRJ@=} *o>HQp)8C;5Nd>	
~%LZ{sN3U̹	L:r0͐PZRʐ$C_Ei]Ԥ95*.0*b.laoEdĕHyg|k[Ik"Ͷ'/*-q%'tzcB6 LmJNo/߻IX$sSu`TC02$mŚs宲Cvتy8y"_J,c,CfXh[&?xCG;n:/Qqbؽ.КE^;!Y+>XxBt;J_zA1!1C?|ǕABCs1b[)h
PK
h<lk-org/junit/internal/builders/NullBuilder.classQKO1ʊɃ x p/K%K>L<Q邈{773m?>
NÁ
6H6A@RZވvp6φBs0-L`"|Վtb#*TbC!G\JyH2:T붧[(tQԘFX}߂N"z3wB %"P{&Qk"߹yt<m8&ꉱbAQB2sz^]fbnҗQ,H8C8ۜ~\\?k'{07Sb&MbF+lMF`
vЦvG[bFCהHY^TJAUW0cl/@1BKGQPK
hьuۖ<;"lwqae΍E\03$<颵*Cayzž~Di=+^3~tsfN˝rZMt}a99+x1QK|`rt^7,#h}%CdԐ3:
dBHdA6Fh!jC9ea%I#
O*,Ei#JqKrS&tBn $|"n^l.$?G9BzgD_rٗ^L~ȐEIaJh2aM}a=`a;Cfe-z֛ќQ1ӲuIT>ަp0
ga61my!kj
qAh2h.^Ea:mV?EmjV`v1Y'Q{boy*=n{*\qzI/GrIom-nR)!>y,xxW{jJ (M{0ٍŨrC9T,q7<ԧG @*wccDslq-'aܗ0%Mn%tKuw3PK
h<\> d(org/junit/internal/matchers/Each$1.classSmOA~Z8\E+VrK LH`ݦ]?/&(H4vvggyf?E3Yd 
3PǪ><4fa_澿^: l;sCݎ7洩T<ހ[Rx\szĐ	+(ÒPQ
lT%8
jأ
-7 $Q1*X'?g$|3V
NPm9aZި:l/||o4MT(8W#tIᩈ&]bT틷ks%'l,+h"M&j̆?*79=A
1ZSzv
$#$7D~oI`7Dˆ~zqC6^t!ZQo~")TutʮCh0^T?b~C)$~?v%!KhIǤԀJVOx<PgZp~M?eI[ZG,溎xW빓]!z!oɀF>4y
HuGQ?:]@d-(NUicX!رKKgk^6yEG躖y3^qGFT(c;Q_!v)!"S)S)S'uYx"Tx
	iZqiV*^dCSx)[].Mq%7h%8z=(b#7tE}!	o¬O$GOz&BSz]4˷PK
h<̜0org/junit/internal/matchers/StringContains.classn@Mܸ6&mP(4,eHR	Hpqd+gupHJ <bݙf'hpa
W}\4ᓽ&CmS*;.a t&`cl;a+xV"{	y4Igvl"S<	G\C喾*ͥ7`AOoNi5A&e|0Z;Ym>	Y
Q\OLˑ(DwΜy՜y?0$?\(cqF]Q^PK
h<&k2org/junit/internal/matchers/SubstringMatcher.classS[OA=]vXEx)-]DCӴ!m%|1Q>QoK+Mf绝ߟa݂G&RZt,"BJx<%8I*y-'I8~
c%ߠ`T~V2{NhG[
j
[䙉f.1F6{&^(xPK
h<18q1org/junit/internal/matchers/TypeSafeMatcher.classTrE=cz}ۉ1mCLbqb!	jlKZ	DQE%PN
T#Eb*/;3=Ow?05D&*nJ˚[X*
6~Lkxy(ʈMyᮊ{*cWty|
{ƗFf;ٵ8%k6ܦ ۟K)dn.wJ60Ēmqw+{a5!,Mβ-7JFG
7
eR#xa-CXwr

kPֲ].l'+tHNvb?[zU KݶzG=KH*LSAeC9T6
>KnL׶hԽ\Fr^=!,>b@3L!09<,:_s,ct}Oʏd}iUkt;YZtXhդb	YfGh.d&3LjOe%Ŀå?z1CK?|S@B?>o-fdJe則d	yTK)1`T"K;IoU^BYj1Fq'ʷ7P#(GmYGĻlޤ^	XXPoIeN/R7ҤH|]\͵|r)F5I&2v4mńڊF!ޢkam7⭫PK
h<'4.org/junit/internal/requests/ClassRequest.classRn@=11n\Z8P*APMD6&bl	$>B̮"ٙ׷`D\MnncbwUg6d0""RK
]9yw١W&2E|C~[2aX琏v0 bGE'R}P%t:A8rOv	R32k>5$+Zuuލ*/|Cu
#'/BU9?U7m\$a_J%4eKa[XceK(k%0rx31H'c)i_!,l>k;T9C
gؼ`}\	6-OAYo
(R'7tf,:c0uvg=XXF"%.R\F*kXA
Y]өAOW(&:!L\V''CrcΈM] Ot!4&g495ʮ:EEX&Xx|Av<0>qE#
MBV&t7oPK
h<\Y׸/org/junit/internal/requests/FilterRequest.classTR@^H\ h/HDE
:8Cf:JCZ¤Iݤ^GFr<(Rݳ|/o?b]A
&'y2%ܗ0#A@ƬHA7<Ƽ(T‚gru|4=at,_M1-2HuMpbX]wF}uVė,Yf(d.|bmh1E17ɷMT5t{[8ΨkyCxT
[WCʉo1eð1o7-Y-ga6Itױ*1"qKx0?Z'=ms.-vFW_֝7}H6t]]*"w2왆b+*^`EK(x%C*`LbLo4]BwLV,sAPWr"Ͱf'l {Q,M>,@YRBQѻSZ#\]D>AZQ?c
 eit	[Âm0/:DHk$X~xrJ}Gw9"nVW!yC!Fvzqn&i2aO4
a4~PK
h5P%quvv4H4gElh<3}_x"
* ;5}cȡɐ?>1;{DӉRB{.A8qj$wBW-,ڻT|-Xjw,I3IFs=zRVCQ&Ϥa\yǐtA\sW&QpCj'im9h!R3Ӎ!0",:	{/zǔ=f)f/0,h>FWl4%m"OD4*=Cvl/`Uc[#;"xLab2YCIYw?#uL+Ocu\mXJlҨ'4D&nh۶o'PK
hW:k?p21T1V%ǂiٙkrJ1>50Tt
nڜƊ>efڐicz֪`-5nJKG2:NcP8Nx::qJŪ
N߂~	E5_1"˴}Qᡠ⁎xⱎo-KuQel-Ew#
B`BAS.҃N㇭MVCUFk&^9\Z)feyoԩL`,c^
XVygCCb8Drb,9'']f[KJ*
FX,=|oUU%Q›=_[wa2۟w@ёDSJʾ$$]\yzS(M}76Q!ueQzZj6Z{EM>*rO_r7@or?!}oΑ
~-jVuMwr9}k!3$xi)ޭLfy_3TR	FKo!BH}/6P~f	ʵ∤E'4b1Fo%=N%Iej@LLtPi{MBn>
R}ШWs󖂿Wiͷ_pw-/<ő8K
<80aJ0C3O;JOhGl1TGwlPYG?zAcb90pK3|̷fN*!&ɑm! Z+(I- A"|vͤ,˲ZfiU]APK
h<'*gP5org/junit/internal/runners/ErrorReportingRunner.classVkWWݓ&#0hRZE@:/oUתjѵ/j<0te1{4\v\œx\VPH"VY𱊫:qM'qMqCh~3|
Rl,XTS@]N[]TЕY-833
ڲΊk%V0`+|nY,yV^Ԥ
fa:N0`<`4UDtǵJ7m^Sx9p tWÙؾkL亶_4_yǕHcX"f;&V*um4ywU|[
Gw8?Q/9,4&E%B9߶;[r{ˋk;vlNJ7F)Uo24VHTWtp)EГ-j"w$g}ߺéj˹&o4bk⣯̸&>{	_"[v|#X~`SQu6cjJ9OV1o/q
AB(sTGQr}QczaLl"G1go^`0JPb5IZ%)0z_X'_yǞU'PqO62&7mR!ıA(a'(Fp҆BqB;S5k_cL6*!08@ geX1WCXi'Nž{Ѝ:XwC{):7%mbm!>FOa2JD]:#Lk5ş_VtZֱR7Ǜ'$h;%zUxOSgD]uH
ҩMLn1 `)[㸟`ZYv6H[km%pOZ
ʂG)MKPK
h|7;c$K_ܥJiMvhjofuAPK
h<5org/junit/internal/runners/JUnit38ClassRunner$1.classA
0Eh5Zs­ƽ((xXCM		$s<֥+g{O)⓭\&7JKxw6\,WZxn^ &+eyW[
L)&/i@HhF5kar~2+	hjFP:FjPK
hBDl%&@!UDSUNELxo0$'`:Iޓ%OL1r8]jc;Yu<04A'B wIIFϔn1=~H
7B&/21@^#152!ZS"JMeڸ
˔!e+&*S)sI9re60z4$sS@ʇ!(mU1ݡ3
BkߡPهV^~C~hSB*Qv0@D*Ioc``L"lxJe&튤54'Rӄ
xuSBqtsػ~ɻ(VC+aiϾdIIG}0)aا$@} ]!h@{Q[QJYjluᑬXBEO$bPK
h<ԈF(i3org/junit/internal/runners/JUnit38ClassRunner.classWC~faw٩Q,+&DEM1
xشv]vάhCMm46jmaY~{yo>lƿtgpڀ3RM񜁨y^V/l𢎗,y\0/ᢁ/uQ^|Y%|E(5پUoXBz[c[Fo&1lwd}?!VQ?c?wf[.gZڮ)59vlriK
Kۏs+X|xJ;4Dv:Po?fRY+ןRv4Pٚ;98kZYRi+{*8ހCRBS
&>G4bkg&b&	E2ְ^^GLyħ0bbc:x7Lսz"]R~c&n-n߱;ޫLt&o6p4
'5,@1;?F7@:M2Z'&/(UL0O	e&bq7ef
μvك+6G]b޴i,s)s9KǬLfb)#KMNԔ`F?^9x)>Yb.[e'7u:d3*C\.Igl-ܝo|eBm}htU~/14Vh
Cp7ՖQ)6Υxw _f<+O;!XoMդ[.5q$\K74/AhEΧXE5>\-`'>.$FI\u.' 4m	bǰ*0:Hׄ^1^.dM,}-VY-\|u͵,E#GFPw.]6a,XAH+c
cX=OְiF$}L~v98c % 8Wgy\@CAy&w نU8Ha/>[yBDl1pQmwX?E*u޴|Iag[VVڞDCcGԏa}wOeRYM<<3)*7m@-:rrK$}`0jeu:N<+8c$?Mo4/0#HJe@ʀ'6Nx|;ef=fom
[XG~#|GR2da$Znh-CwlD&8#2k9-)7cjg7:2G/|9q}HtNoRP7aޢpʳ]2ޮO >Ã
>|_2`-5ά{
y|byMll|?C?cKPGGƣ#1	UGcZ(nP6H(7"7u	miuXL}4[!ֆ.BU#MQs,t$1t3Cf<Xȅ#tIXO[%#$Keus@;LΦ7{G.:a")Gm3dPd٢tAaLJIˈFb2~"aqbǺ-ӭZ2]ґǴ1Y$bqTNA{;jkshO*4Q,#ăe"Q55V7Dk)-8+	@%k[z	ͭ"0TivޮdžMCEdy<M.Wnd0wktzVcGp=͂d&8iD&æN>xITcѣlLI&0NkB(IjOz#^,UM6ˣMsƃQ	OOvGƁq3:ŵ@6	)0ejIs`JY9;Z:rGv:CgRèJaiow"WH2aFKMhc2v
@0JSaVg)y*/FTTvT%11/Cs+87i 7.7:iHQqun]4u{Nz:	}Ј)ncg^VPGnnYf|XXkE
d݆}Zd9p0Mڍ0Z<e@&j}eL1joiv}u4ˁ|@
*݈q=O]xY}m_K4rH(G}<ϛgT,JL}"z,		>nVҌEZK']<_s/-MfӹP$Y
1i(	A=R!,(v!bG:
ijR2C̎,`CAh4eudso#De1E
DJv$܁:Jxu}vRoK2[@F"|%TYtct 0͎ͮ?
!&h
՟e,B";"-mOk
֓'&ԥ[O62n7~;(rSZ(VY
KBc&u"En;>~F8_VZ
	\]=U0s!1	,Ot,g6XdyT:dI@F	}Klcum|YZ:3mӠ3Ŀ8VRJS	%J)PIZM麌n9\3%G!DѺfСT S8!<
-¿qZLl<
y[o2G09%:!V&jYc?Ns)I@4KP$fSx
6x5Ahbl2{Ys:78/8\0r2:nM*m6q&cR-PK
hdF,?Sx%7f^<1gNv}˩4
XŚPĐoU1Jĸ`}{?G?	9?бCMUXZ
K']B"0 .Ɉ7\|Ȉ-۶|"
fk}7)
yKůX-ʢy'xf[ kVP]9rQ`4;%	VL8 IH&SX˭E,J"u$)ST}[K~5wvjSvLѭ`e5frk@8o3bTxÎW7Sݞ:6>^(ahG#_
F)lڜ$Eo{'2>'\5P_{sPK
h<t/org/junit/internal/runners/MethodRoadie$2.classRJ@=FT])؋E(UmvK@_ٴ>63sΞ	0faVabĖm٨'1C]?P2rDDw";R\RRaqjV`T`XI%/-4x#$Wk@450طZ0T=pJfTXGō֣>dZ=?;,ر
)i!Okjv=C/]xՉ5&
Pf
dՠ)ӄG{'M"t3k*W>_H=6EbQ|B摅A9*}"9[r}H4X;LA?*EFPK
hx "ib&1CPhlM$hkyK78Kvquij%i^l.fh$Jmmf7?{fl3w9s{y/:LJM-Ani>$͇}>=W~A;!<1*qyD)2'uf
DȚp4}=flJHydZ`ΆLؑ"b&%zVE@v>aM	+^u>,8|˅=n0FZ	c|)֝iRpv^}d,d\J
FbVH"P#q;SnjN61nl;KNjp^K^ƴJ
gcĽ,\}됥3iax`oL!
I R2/}˜&Bh2;a+OiMoe_n'q5GyX,Jr,;v$,j!լ6[~)3?/R6NH,5+Z+Ko5ձgZV2?b[okWwYGŸu_q[9`v-nxKÚ+7ũ}q62EJ&/;1萀aUbn#%(\K֬־S-bt"#H5^vyUe0x"^9RέG"\lf+"PZ<']͑I2)7ۤHS7ޢ\%uQx)V'wtv6T&1AODyM@5L]pV^t	2Hn}-ϟV[Ydr*vY5dƻQyrTWuzp$Vfu_A<$XPwuc؞m6

=Eu_Cp땭LZkUKN($F(a*
3e\$1JqI~e`.'ib@ç>⚎:0AI̫ݗi,+iԱcYұcE`hqpA`4W޵VvbRmIʵhS5{IH٫͇sǨ;N +{~ڍrPݴuX	eE;VI`pO8ӗ]`x^}<_X ޸c]:ndNõȧKOQ
φ2}o@>嶢mޗO=Ϫѓy}ݔZuPSTЛm2[qBdm'uRQ=K&Xe_k(`MǺ{Ž$]k5q3r[Wf؀\,0ڏpjSN!V7divo<&6Q0\#N\u?NmGx"5{Foou,=N͓g;SemR<>`NP{n5(v"g֨D=$~|h%(ӡ6	Kre!c뽀Vǔ71,Q?0͗x30&x<5S(>8o<0o#y@w@l{k2k\?Gqooi\EYT
#h--=3#CN`ů>ˢ/ȬͶ0rW&԰I(>@
^%%Z!ۤX!1^y9cJ@w8]`X4DqoŻPK
h<8T*org/junit/internal/runners/TestClass.classW[wU*ݝn*	$$Bd-PBQ$DD.ҩ$P]8fxq.a֬fZd/@ΩtpRu>|]&]Oa+Ω8;b^ŽC)Dp:GA8b$.+b8^/TRྫྷ!|U(.+,VWkx,)h
cz&[)گ 6aZ[pW&8hZ;ޓ
#4o1^2I}*GI똝s'u{_vLcvf3
DΘk882|fȻ%#=;./J-k5\upibze̼K;k13n/'AcvBƸ\eٮӁuVE\.eyf8X(輽̸8
6]S)gXTR(h0PKDŽ!A+? uvx줯29X,uǀE?NZb܍Ɇ6?i/Lm׵
?ոӧ
ֺεc\9r]`?|Gz'b$ق M@&
#S$[-;~٧T|`5?2ֈ꺘+#wB
~-h+TD5DQ*~
t͛=A5?mUJcVVy{\JeuLkV86a1jaޝB&+&ĉI3ory*s|gG
c#_Ѱ{XҲԛYS[
N5Lb?ix
xCÛ-iUV4wCQixK4w9V{XRvH5L!_4untZFr9+eYLr"[˧D5`5m?+hzJɥ9=?n\r%-Ts^@ylNw*]=k~P~=:i򵽧/w{9;'8̯EVMV3JFBAU#ut'yuz4^պ@aGmAyv
Pr(hzlH NİuxH"UZq-=Iw`o'W<[[Dm@[REp
g]'Rgۚ8ic
E'GbQ93+K&?B
b"`SS\h
D@8.y 4&oUC{v:L4GbXx":XzAK'F[,o2%OЖ ^?}$k5:zLSy/Pe>^b,0#&ìQc`d?3JQFh15xÒEcqP2&+!fPp>jy7y:hRc4T6~
M)Ɉv#pF*XhY,$??~
|1w:]]ޮRy;T"{	Xm2!aXi}3ۃܥ?"Wi'y"<qtHME$!}͔x'.)Oɧ,Ho7.A^yjMkI2c?!F+$ڎ1vh(NQydM'Ko)Vj+lH/4h%J8񚉵O^
d}<>v0'i-NfzZ݁֩@^O^xן,/TDrbh?gi>s<^2]f
Hո)>HTe5NaZjiPK
h]:
™vFf&z`WtCs2nT.'TP"^ijܯP5AKB]$?E
e=sfIcv]|&D@Kݠ:@B+{+E`ouӮ2PRR,·D^b]
>>*GIPK
h7org/junit/internal/runners/model/EachTestNotifier.classUmWE~&IٲYMVZP@ZmhmAѐj(zΒLpݞ}+9NO/Ww&KDܝs{?7e#qHqS-n:>N>I.IaE~*
>bUϥBCE`)P޶:"0qg:nus``4qQ9tPɟxB!umppx5ކe&[q]D}+)O|'H1h">_fygΙw9so%VuLNC݀c`
7Fc)_QCH`x1bzYD(
'[MݦuCځH
LZ־ݵ(|mSC*PzA`>Y_(,Wi@>I7d6{Ϻ7YЛ0j[	]hFIЧM@}Zu|)޵dG"X;HKzA-uU~s#iziw̾pbaJ5Np6E0Yp-œ۸c.W\75e?_iFUSq#7䯍{+RӍ-
\.p&j0Y]E91s9™.ˬn}ĈC1]!}cD	'xؙ`#P]β+PK
h<d	9org/junit/internal/runners/model/ReflectiveCallable.classQ[OA=nwq[[+q	N	фd	6OXYft[Y	2*I6z]ϛ[XKc9E
+	VST,/ƚ@ucD /hVf>unBVT~$f(.+\_F$ƖYK7V<#a.\J3*}[#
X\پ<cR範 옓xeM:u	^
~gb>#ӟ_`߹
$k`-Wx-?Ω+.&o3ʽ3N{:=~/G$m}F2Acj&ZD#z5*W5NIK!|!r(g5[PK
h<0Q`;org/junit/internal/runners/statements/ExpectException.classT]SV=6(JLg4q'ipc7a.,y$HK?3Sfwzht={p?ǽ!Z(YǘPǽ8(YT/2y/hX14,ű#5|[n\i:V#=?_wf 	-˥sۦS/ڦ+Ū9f@洿0cY}{-犌,X.
̦G}u"O	$J#VUzdɭYJ?6ƂO4	v6l-.UrN,5.wMPhZ}=	Xc|Uu
[\'K+nӫeK=Մ+@34<5%

"0q҅eoIOƚkJvr`;|oTXc1R{_ Ue[uM`5S%s.^)?8פϻ>)ies񼖚A tߧ{K21哐eϭP[%t8q*u5
sjȞT<{qq#|8c%՘AjhW~Sޠ%e2=N  (Rax"pO /GۄcFIױ(v	ơ?./fV~T[~J-\P%.-$Gޘ򻫿yް."=C
6FԮ;A"~װ7xg@5$KϠSN5	,#if &EDZrsPK
hCb88"܏33=q|f>ʨ0#9sjk&W&m,RdQJKGآWXǣsjA,-Z@sɆmvH\A
u嚼@9x+W)k$dviňPK
h<#evN;org/junit/internal/runners/statements/FailOnTimeout$1.classTn@=ۘ1.
&hC\N
J<4jmUO>BZJHHݳ3gxg_WMlY3q_-L0M^I!o^1tp,V=ćtv,!?r}Hun4d0|7q,򢈀ր(m-Qur7jQYg&? L#_L%mA5S~RMދdMҟ;|$QM51wլᶎ>>PÇXְcwuXSYE=
.U\ouuGz~㶤]f ;	vHKXHW-we놀֮zte|`m){-IM@pGj%
W,Gw;ҫ)2Ɋ4Yjی/p9v	v?/VCLݥ@4$]O-~ EMC`jrM5lpm6J@#;~$BiQhb[8a[TlhlC{%/WݮהVDx
Ŵb^fS n9Bܖl8?w5!Z`.~Qʐ,c6sXm:-v	xc{O6
_K
_DCE251->B*$.psĶ$W]8c\UeË>vXqBuFQ<.0WRD:f6Vtŋ;wdJ5<ɢdƥAl:fI?j`&UFTW-Ngc^ī_>Gɋ||G!u=1"Ydx!(
 ](%e\U"?EbJB#Z<{
}so06	'{{Nex<9E+0?ě+`V~D#G2FhLy(ܑ<-D?
$u#y7BqVN"AA4*k9/PK
h<(O&5org/junit/internal/runners/statements/RunAfters.classTSU$dCX֏J!"(*P@	M}Y.fC;g;iE0ߜq;|GT{Ϲ9_עh@#ZZ^Ukh@0#J{	S5LD㢆I圊bojpIaiVnz]NlK%ۖn1,J+OIЖ,oͬF2UY(Ǘ<8UvӮ&o:VQF

$NPJ5'c-ӖK:Ú3\S+Ɛb}қ6onVbbj.Cwب0*vN^MV|BUbx`Bl~un
եQX:qVy^@ٗȇ9jt]GsصW3,utl朒[Ӧ~:,t#	utq򌻮ixK
PKY
:.㊎NNx[G)qjёǻt=#rWK.nVLtoOq+X~J8.ﳵӇӦܐSS47%08T֋4oNU?W$[w/&`G#i3-1O$YWo˳S׉"OF{>}/H=]d܇Ӈ^+%V93gf7ߜ|00!7#m۸	b@
%2f,{p53Mn;ZZㆶ./qӝbP+]Ϭe]3t̮gy޲Z{0p|otYLl0u=^[ݢ65Cӂg'4zUy1dɗR+z~VN7Vu[Qv;V^.M88+Ϭ2Ce3`\ָ
UR;O٬sϋPz6%^
3HI@fH;7CH1tx]&_l~;7]alyv/#ֆ*:ѫ-*hWъ6*aFcOTEGt*L-2\t=CQ͕mmUf|r|DE#:x^VQw*_5
_}kmfۛ27v&ox&_G
fDZܟP i\ pu$IdG3Xz` _h2ɔ)J)O;Y5]kZ@AQ@IX$t|,T=dW1HD40df)
wD+K_G?Gn
1AІ8i>nJ p"cTP&dh|PK
h؀wa'1NF{_D`^-vn,n7wlߋ]ra`&i}7!>:w6KC`&t{|!+ydO?RD@R'f{L'G
~zPK
h<ѩ&org/junit/rules/ErrorCollector$1.classS]o0=^CC@Vύ1
鶬T	UEBtajR9i~?
qmZE"_{m6TP}m$&/䀫XOu
Mx	ToS
&FsZ͜އPcf6֩{0y(noJJSq2
D]n1dB*,-qSJ0YwDC.6.*p\uQŖgaHٖ0\*Gۏ8h56zg^*qhNһ
\FtA&*CVGk4ܢ&`s%3O@Lh)ɺf\:uͥȣnl/f0ׇ۸ni܇xy1CVHIawcVm?g]\R0wK-V[2yeKke1Ɛx_ڮx66)(`ճƥnѪ'퐈L:7̊8
<
ic/N`{.9fe8a$JTzDNDPV]Xoju0LӼئ:oXR˘y;a?NZ#F2$3D)LV#DTJ-dd^
-KM*vܖZ
wI1ҙpPRB2tDDU/Xܡ-6:pL=QXD2Rvoܱ0ˮ+d/|䙎"&5TuSe8=5~'`MM_B!
S\	q"l1)2Xh4uCF}-#YMbxf63{gv-5	t)CMJ,}_
5ui4>X;RHBCK`ixIfpR-([/0h59NGrXb"bED.J+l=@ޯ>Cg#,)eJE
KT't-I9ڝTBK\W1MK3]5WBapM%rv!L;gȣCZiUZ^.x`
PЎN1\2;WNTj%1^*X%,*X0Cwm
nUΚ!N0]I5w.a"yAQ_tZ/*"תUn|Oy|tv׳gT渹Y.ewݞd 
7,\$%R::D=SqP$D_'*whZ3`Hh*RCm+}R8p-̀-%{3]#\.4.Q!Yݩmcmy,eD
Դ[Llz.ԚЭC:Щ!!
^jW5O={4y{Jrr%r#"/"Y!
,hXĒ\R2\#ЕpӰ]aܧ *Q0=To3=Iᓳ{c=o2;ӘKCQ,r'0qXI%?dfozVpQYinoUe+0ݠ]ƐhV"4襵who'h![ަf%'*O~z(GGp@źG%$1;+Z~@Lv_hN'j!ݚcGmujG>:9y](P\'p(&rц"0#(a;r]Zu2J_"~.*/PK
hKཱྀ!L=U~QrԊ(/W|2('0z%,EOyȠ)kRvmW(tJFa0\JݚcW(9w҇lGݭU۔
E6U.
gFܢlI0'mz^coUIEjXɪzz߯,t0Ol'(/U
_f`-K_=|WR`}ҦP_jlJ/&p_]lK޷Vm8+>oXnPMW@y4rn`;,i}s
c+.Q7Tt@Ru>\fUy"l~G74!א9\#}xt8y;WC
qnu6&q'V<f
:g|5
4^0a& )3Cbϐb0ߧIG52J4LoIa&v^n<GfiV(#OgOgHhz>ɋ&QA<еqUB?o:D91um"zAtýo30ynNw.Ђ:EqFC,dG0aToKvdZh1wlK#MxHL4=PK
h<3jF(org/junit/rules/ExternalResource$1.classR]oQ=(Kץ`J*T
kM/
&m~ⲋK[1>75AQsglrgΜ9wf}6Z0pOMjx ;^͑vgƾUHy~,c5T~#nT{$Pn*ZE8*~2TY}6|]:
W/CGY]3
@zsz2=j|>Q~d!ر1뚎\]m[y"Iw r#uhX"LyZhjQbll3&pM=~NS^`AF;9_^(4LE3P]Nvsq&ew*ujvT{xX.zL.4>OE,*,cO<4[tj#%2TK,Lnwf9	J?bYp
}	-b
߈T!:mI|kLF
$PK
h<
J&org/junit/rules/ExternalResource.classRn@=81@KKmS$R
RZEqn״Bn,..Q⇙3㣊paÖCYF9C3D0,uTɓPctҕ{qQ1lu㜈"εP){"CO&GOi*T$tkiE"Rݙ	9T<gR-Htc1Op,Z<ka6wY5iB.i81ёL3ƦSΏqyCY+<PePN&n`hK]{%О
S-
VT
!o8uIӿN1]~7(x"fPK
h<|Ȧ org/junit/rules/MethodRule.classA@_b	ؘXwUE'AMgv+p( xy/߻/WStc1:HV:Σ؍(9alkQ5+;d풟HjeGc3v[NBPRo|Y%?^n]qSLdxOZ	M hB!YPK
hpSͷp[Q5pO p	VX,veۑ/A>8>dr,HM>@sp:QP(4C/:#Ml%RA+
Z8gj=,Y0YcR'yi{qcCgqj|V0cdüZ9b@yFa&wI[DM;x!(1
'=VP:J*Q"Mz HL}`\}='s\fsSOz;,	bQʯ)eiVP
c&y2%H	l9J5DMF%??E?ؑ|223ԍWPK
hc|&>Ȼ?B*f9gm?EhTB&rԨQI44ҘN,ۗn%0Qk94=OkZ ц5*k#"FPwUhm0z/#ސ|lQQhvm8)\PxmQSU}[2p\		@X>\іQL1V{{(ֲ@r_ZvzKlz/;~ٳ]?tӘ1zgnF~xh+n6][iVN:ޞIs?I*okl3a$(]߷.fæm+2鰮aj[wWw`o ӣ1gyՏAE$Y<0K0'0"yk8$1]'JRМ{yDG8A'YIfml+]:-]/("y:/b!g!ȑNtiSA#\J9R7D:!ڕX,Nh?x,1xڅPK
h9u}b"Jd\7,]wZPNzVGdA:yd+?P?<@[q`QXЫe
Vq2&֐':n<64\V`GnNxFUW5Clg2l=zF|a?ٲ_PK
h.wֻQNLZf@%2]RmA6	j4=ұ"R~WS0CɁk'}גBa6/Jr#Cv ;ʗ^aKXdxWN'z1Pzϔ$>!ڌ/aXpk<~ܻ6}c<^zؤƊd.\Cq(7QZ`ܠnbئ'7h,a(vW%gTLx#|9k
Z+uB)86~PK
h<_| org/junit/rules/Verifier$1.classRQOA-=8ZAbUJO)`@bR[]g`?e=0ć^3|\TКG.lXrĦa~ʕ`hw,ih8&	D(8cC/JW"	{ȏRRu8m~=>l!+]qF5Xཱུ5OAHC݃ϑRlj$ e2PXL$r"wGJ'2P8xa.=c5k 0+
êm*ѧWoe㓉:cҙA”CTOW7mAZbgؠthZK	 OY%/Og(Q'V́1pߡU!.-zohgP@M&kSps븟cM<*E."~PK
hN4t?쬶!}*QIJ5;wsϜwC\,{a'.>3e$C\i08{`H|KæPt=n4`0,c)*
D7?P5?g(*C'kH2!"Vgzs?Q슖UF'M6cEEƱi8Cvx[e%.(?S:ϿMCQ7r[`(a{Ouaut85fO;*迀rݏqU84zytV()Pހ]$Ƣ]\8>o19(>&Zw܏
WC+G
l
쾇iP=s0GrKa_cyhKhm@#PK
hCULNzA~&yסj0QroOJJX
PK
hC(SecaUWRɒ,
E*ׁ1h6CdZMԥ@jEv#[%ΰ޹1T9kWӏ	t|Td]1rQWl{o!'ORa2|ii8]@:Pێf4ǵeU#mCyRKisT#Z'ի󿢥Z
P1}iCNvvvF̂ۈe#jݓݘZIňT]Bkv]Bu!ՈioRӪBPbb+(=U4jZF(?8EjUz4TSF.|&;-Im1ږRkF1$\w-(U]{ߞ HeƏe]2~J؆w8leͦeWqvxegn*5~y?`\NYo&q_nJƯo;*J,	<o2Rq":ve	B;1G϶)x:)&l*Jf'UGS޲7#dA	^.c>M'"KxG*.|96V.(NPJ
PK/ײUvNNj%ͤzu)fB\s`{A2vGhk\ln,j1ESMETlSrcq.rЬJKh^N%*֩JbINf GyT58f|<\c,[hv
TVgF"'Ch$I5rB׃I(D#`
OpSĞ8\mEʡtfG+<(9Ev>Hk};E(2[pc< 㸂2>`>*㄂xP?$cBa׉OT|R.FOQN)0"cT?OӍ)4b[ΊC笌( Y	i5tSBc{˦+jfS)݌ŸfT3HXoPJ	e	tBPn^&9Sמk4Ļ;]˗ִ?)	s׷ӆhRKE,H؜Gj7W0,	"6#efJK:|]3>2ME^	&|N{B
'ZZ&S-ɒ,K4w4L$̟TϳMfK]vp0I#WrCeїҬI/|s٬e$[i
JU4ndAkLX$γDZ>|;E]1IL&*}գ-s
^6)#ܩߒypV۝^S͛3A-wN	yl?p&+%Ϯ`ҵ֘@zHGM[뢰EKJg͸fzTS+UlBnc*^N]K:Ib:ǩ[W&32>!txnW%0obmɄ8sА!_Wd<Ȫ2&xo4Mo2[LӚ&!$k!BR\v̵0}?%\|^&#zX[?`@X1xaT/U
[!_{1Ã58u6B?KS?O*aQWM_*n\V]wg
W2]x\dzI&mb$*}񇷊*Kg2/_Čtt'b}#TBR5E\r㜒ʥ VJ;,eoI{f6;XM3(Ԕ|hcau[AZzWְnugnxQ,%~q
t[mN+m	+P stvuqnug֯e:̔(m*6Zf	{u`(ajﴕԤpzLɢ9A3bȶf(:5Թ$4C^laVkЗ ]fZ:Sd'v>ͼ'6.bj`_P-0w~-Q-̷M(9)2S({G9]6[<ŸKc('TEd8PE8*awqz*xCc2Ҙ#"ND=ע9;{$0D'wF]UqVDMPa+Zlq}wPbfG
&%%AMăF6jm7bX܉[*_hE1"r=9͡>c:g̿"V,?\Q,qS^^4#BvXe)B`)\41ev`)bUA]Nxn<%H<&[6}89\a	19(AQ,DE@"`U'i-t.w
uBzk9&MC.GS>
`/"%Dr?y\ˀ>¿8Ws%zQIC?So
0rdf6F$G2Q99j47HdD(,KdQ~vr%
;L͂|,d4[ɧ3,NR	dQ]ЍN7]TxMMC8[-j\lQKF'{RDWx(ٕbgdO|mֵ}_Cta(:Tep6^BmBʺJj;K*J\[]3)s0.Ac\y֊'5nF1axPc'Pۣ'UUXGuu"&[5=3+VK>Jx?%"ۙog>>qPF{43+DPc/bOF7fsP<_0:Q16g2KHuO;TԢ`^+P0jIM(Ut68+3S_qyM]?s#?3@DE:ZlK*OEO+:qHҨq̲&rt\eNw{E)1h/R`v3
[)MVz`習ir$j;d5LI3(}PK
h񑌏%4JKvH[9&)lg=f
d,M5fT[1.莄˞O/z=dvz	G;$gb$484
sw6r	IYN8"ՇN'`.~-8wq)	鰐vF[8df;'1NABgSe
	jS_%F	ͅ_.2H*
Yf4ͦI>b_K!(VI)>,tĠ9/q^~N׿'mq΄ƕ2lOMC/έLRztlqQpҔͫTo5s;;b&rn9/NmJs	zKI
?g v@8B\\XΦT*vVQ'D0
1HC%|vER҄NAvwBCg0*M4ţybk%
*}{,K(~b""Gu+˱a+Jc>o	'ðldTwS(=d|
-ϭԊ65Stdc.$ň4^!=v\;r"	y	`1_ů	/yh*tQ,8Q!r#yNnYZfS]+xǠouj)J\w<ŽnWEiK5P=zڞ=+E	
h-@T+‡HE(A_$sùbލjxaQ긆:~<
n긅l.lӰ!^;lUT:n9Ğ's] Mo.m)Ph9|wwdisۖe,l9a$Ih2k/Bڦ"F뱷YA$ؐ8o"|;87A@_~kK5,SI:5J&ӥ*%WKqz~rlc	R)^}v4WU=$iXZRy[&pzqÏ[8\|]74(}
?hbU-<4k5l[xᙁ6+J/b:ӵo(C)~YW`ڎ@zCu	L-rbe2Y]8;>LV[L2±#5mK1:YWSӋdGt:2{gK0u2TVVO+0JK+mN#-V({:E(%ɚD;.1Z-*C^C*h8uk&340!CR]}k e3&hk+W>|SZϓeU5LTՔN̝rB3PK
hktCŶm3s9!".I71/a Zs-՞BKH8,o!KP 3,fF^w
3ZU:Ƒrl8EtoG{b]62DG8Kwvz0_8R.S3&;!-÷D,_}!/+uBxNF*%
"
^
6yw9μJ'?}
ׄ3/
	^Ik1^$|oL1Ąa*Es1~KD^V21%)pu8UG΀B᧔BiF8hhDQ:P)v:Ã,ޏdNAx(!uQtLnDr@+׈mh1lR&%lR9SToEqO(Md4xF.h푙
8D'MPK
h<9!'	org/junit/runner/RunWith.classQKAkڥYYC=HlUDO
^	~}h·a0;<=l*JI~t
TH@^E*IZreB&O
dM!+Ժ N툮uUf{:=aDN9D;[}rd 8ң^ܴG|erL&^kanjjG/L]&;@m1|7i~4
Kȋ2wx+
S	Ua=+!aPK
h<ګJN<org/junit/runner/Runner.classuQN@}B("F/8UcbB0Qý+.Y~/x(lˁHۙ}f7S:aǁ]4mطb_)%C1X3TBapSQOG&_-,fA$&!ORr%pPs}gZDY/1'KU^{'#-D1Lrdv/j>(:qsG
0˖ҝzwaࢌ5l14֘`o˱wLxH5a]'cs,Bڅb2溟`tOu()p`TgBl!VΑ#OdIy;aPK
h"Μո?DYOFKXNְ88ӏ"o희ՄFA	ed@PK
h<,org/junit/runner/manipulation/Filter$2.classT[OA.lWAD*(rQD4#^~/xG6	ACXgh`޺q,)C,:(qU*3u)q
U3
'OBdV?ͱxGśZ
!zKsW׺PK
h<շ*-Z*org/junit/runner/manipulation/Filter.classSmOP~֭k7Njd6'AILa෮lwڥ/FB$FvL ~9=yyι|`/tXPDG
E(XRTG4,0T;ao6KۖoB~J!lߊnG]yC;لavQ`Ve.Π]?vIyPp@&͞2\Q UYa6npi0gF%V2|y3TBB7lwtl6'8-Y˲y	p.B6`(M
CJ>kieVJ(PMfmjLΎ`ʬq!/sORXg0^U;mTWH EmBm;}PK
hGGߵclGbbb0(2O+57%֔4U*ZX"?H	>*B?FMbTrN+'']NbQ3HD!^ֹbb;UHm^2l3Btokkv-䳌p9Q4sb; 5X97k[Y6cWlmkPK
h<$Ar,org/junit/runner/manipulation/Sortable.classA
0Dت x
k%7p.<8a=}l4X#J"sQlҒC0o={N6Mc{%e0'
a]?Sl¦swfH5PaUSWPK
h<",org/junit/runner/manipulation/Sorter$1.classRMo1}l6!R
(HԻRG;z?8 (؉jJԃ=yy?t1B܉p7½-ʞT3;GaOT]1
34:7ҝОȜe<U}mFɸ J&\iq+JXaZ.CɔR{vS#]0ðu=exGd\ñHmwE?=q0Vr-7,̒7ʭ6{˯O@&{{=vZs^4ӹTCaOqUDXa\&[Egꧽ0leuI4i4*-1V)K(
%b+Yuy#+ssN.(}>ż:gAeA]n_}#Z_ GW+Qy7}-!h@+sWPK
h<{g*org/junit/runner/manipulation/Sorter.class[SP'-MSnDҦPTV|@yq&ԈaBIG>8rMcR>={痯 b	ȸBS

9oʸ%cNAE^8gx|ñmk޼@ղS5:1Lѭ&k妙Y2iDKÝ#9%dF6eCy[؅f紊%hJ5k[Q$n
kibF0MJC-Mf]_-8h[ˎ9eKS;ڵtAunhDlSsCT"Yj5;b+Pp	㢄M['elv^N+qx)J[RusFU@GWNAI`onkIh渵mw&.^)O;"Te8/Q^X8u1Rdq/;W!\6em5]hs	88DN/(}h!Wn^
zJ4:ENC$RK$ՁXQ:"n%K5:ysAB>2d_0
:4;éc\N8&\|o`Z5,'8ܠ:}\	{$O %!T颃kPVÅw5*u;0yGq*)IL9ڟ	;AIfNKoS5d ,zf4G4Qk^oX/ywaМ3#]*l_xo։PK
h!Џ:6!쮴x93ݿ~zW]c٬1?%-0ِJ|M/BfLFk`^HvI(ԩRB*\FDǩjHc0LXa,N,V񟅉;V?6Pr	16f5N¤z%}iTcQq?snj	{w-MNü;0&m}mhWT$Iu$Mo\uO^A$cfGDtcPo
@_{%څdѭk_Z
J*7	x2Y"X.y1A$ESNc&l{,gW1wedEV@V
';JF_vss7kPK
h`0㾠@^P$0"!x"zZ<]M4lڤp(T3L3AaZ<yREdsJˎ
8jJdoaAl8ga\:i`xZ޺tA?\jWvivLľH3B{O2gX^?o/(S
=YpHjphJ.w殟z:&<9b>hF :1|N>湟PcJe]3[N&nᔸۅ-%,I&a3&OPK
h<1org/junit/runner/notification/RunNotifier$2.classS[OA]vYiEATԪt_0&ӰCY?D42-76fΜsom}@UL&+*g>hx`8
NTċRDdGd 
ٓ>OdTg3IvW'41vC#Oߜ舟>y$3o:جa
wY6c*h0s̃fO$~,ߥ2
(GY(S7Pedp~Tϕ*ws]*$'qgжB<a@9/ycQS`P$,A5R9{_(sLRAezKu,`t,sk>ǜڲApRèg`BL.Yc6l:~60<*}qP/
pU:;ڗIMyopp:N>01<	2n^{P3ӀV$mJ?0k;'`	*þ1w&`˳h`ZY]Qʧ!5ghTf
Q:%]
J8N\b}rm,aEڙBdUOPK
hފMl3,f_2N93
[@{Fii䋎SI.%)?coE2{&vl4ب²a↍vMh(Ë'/U_qUg\
24G'}S'h;0"Ç8YwgcN-1GGؠK_@^Rl7;@^`q+@kfHk.	 D˨c-ܦu
wF!_ՇT]JaLBYFí冣p{p>dxigS!37PK
h<1org/junit/runner/notification/RunNotifier$5.classT[O@f)ۭ 
u-/B 1Yyŧ;;,?xf
,Ƈ&9gܦ~	*X-6L<,4,ܑi&*\`Pnާ@|T5ҏ<	ľTo:CNeً0Ne'Aܵ	A԰aaA.3A^GR*Z?Q߿NYa'q,l'MsMDtqԛh붏Oj4S?	[;AXIJ
NWjp2&iSswn\z;h&A!fiu<:h7pRD;+~Er Y*$JZ]"^֔(}!a:Fd}aTPK
h<1org/junit/runner/notification/RunNotifier$6.classS[OA]vv E.t/TӰCY/2M|gBmn39gQihĒXP0uzG$A,_2R(ǙgJ:b0ӾLޯ*JeW\/2"a$9>fhw0Cc;*-^diGy,>4<]n;I"Ȳ^T}ʱw"GXx0{m$,P~(Lj@6	 zEڏ:V4:v`ኃ*,;h¥hfq}g
u:!W=٩ЮŁHݞbaX._>%nL5AHۤ^L4`mUC*I[(L)v/(]'6w"4j%~ADpc	q}Hs?(o'<tsa:--J8J\|}wr],`yڙ3(?PK
h<91org/junit/runner/notification/RunNotifier$7.classSn@6qm6m@Bn"$TZ	@^8mMY#T&H$<ӆDۙofv}@5L&+6Lڸ;2̞iיr'=8W2\)O[f֗icSřʐkWE
]$:$qbqEapUňQX0oID%L837خc-9Ysl2b¯kAqql,lf3n*NY-pR57Ð-zq:QQS ĉ2[*E@Y"Cj)f:"H˟ȟ/n`?o8-Qz|sngoEyi[*Sݔ0C*_sK^ۂxj RG3hDT븆*:nঊ	dumN24U8zwp-X򸊻:rt:pJ/ԢUoYH
Ve%..;}jή=Ը}A,_
dާJf2vĝ'S*CrD	_~,816r}8M0mϷ́"V`ܢM~s0g{< _䆖䮴|'IADupiHW31V]!-Vcdt`5!h#|G
"od;0L~I*gzY(2}%vw
׿%֖)ʧDюn$i{
Y&F%P恓4".=t	zN#Mz=)i'IGJQ4̄	SX@DQD)I!{D0JQAXLa1B$c[D4q$=D)=PK
h<</org/junit/runner/notification/RunNotifier.classWEǿ6JCDA	m)BQ~J%@ǒLⲋ⓯>C}w=s?a	!s2?wf3_ੂA<aE*kah>	aCA>V)smKB]U]
M
zĤGL2
Zpbҏ-'B.4HJeѲhdܚU6MjIDhrW=PyGB<Вr-tҴrݼ9	+/	CIfQO+}s)g`ig#y3C~ڒ{ZUut$ʹ&0hh(1L1( "l=:zW,g뎬fUn;rT*,p;mi)CgJ0tYݶwXG+څjtLE0ͥc2vՔ!EuZ1]v~O">мhri	Iԋe,?)e;3St8UC%DIy+521[xα,HPB؍+1^aRz-/_G`	W
vt癹5[^4NC".!
iO6}OLanyjOwyV3YdzR̛NGFz2
.ETWJb!7mYS#:C}Iՠeګ.˺l:=
!*r6B?hʟ1-ӳjc'o#^/MZ'@NjhM/!Cm`e/Oh!xva$T]Lޅ*" ǻ.!Ghe#>zp%>Δ![=d+ÔDNydD"[R\ 3x_"?(}"c)	ڥ:+Oj!z-axSsq6a2tW.Ce.X!2!{$kH5_D^/ V8!%FU"'5K^M`?PK
h<͜5w:org/junit/runner/notification/StoppedByUserException.class1OAAN-ܘb!rrؽYV&q0VVnv7zp7)e)ik&!tFd^$W5hFG`dg
Qrܽ&C3V23:#Cb3H儱^?XzBMS5;pϱJJc$hE8O @DˍK]Tx}
w
+;赌YD
`+SPK
hC1:~{"K
5TUuɩDOfPCqBT	RTPK
hB7UK"e%{fό,JX	1!q3n(3VA<kb;Z,~Lr=Aųl'ۤz)	|1P}0ߕZlӾ=W,vM%7>DMx[kn)4:ʰ@ACJ1Xq=#:lC]3ؔ>yT׆Nɤnh܍pe*jgxqJ	:QO-fҼjN?MiaKcӦ82`Ҋv]ǝHvTņ0VipghYH^VdCz$l=—3G{~zh|ȏOK]U"d%Ԏc='ij*`Q|.RHs.+9*2c>FPK
h<9,.org/junit/runners/BlockJUnit4ClassRunner.classY	xǕ~OV@H`{0X$a#!"GFj1QD8vĐMMfc;$Dv]dwv7{f===`O]Uջ[?"Zgu:k:?#':)t\/4Ky4-sF2?O|a2o4!J_wF~"Й˸Hbi\\&2L25d6_YU\-Mtken:7pZ"6pS7s|YRIzܠ/!/&z8 Mm:vRiVI)jih|N|tjN괟ow	o0oxNwf
Z[en۠p^ACyޡ.ثqw2n"VbS}`xD3vn񍭃Lz1f@p8P0<Yw}1+Զ;Org,xp4t *FeZß1dQ}Mm[0_92'V4x7S~k4L$cX0G@Y#21+tx?02|;gc
CMHa|7cokp
zGJKCMGc<%ShO&VViyhM4)Tns@3]Oߍb-;oKXP(̪T~@?>ɰJ 4m~?l#(eONL-NQf\>nDam]fwZaYvȠ/
f"WA0)]VO]켰vX;BANǩpFX+aw[]zI߲)΂yC?(=ƴsp{;ey?%<zilQP3C?0:I'`Z3.:ӫXY1Uߣ]~KZ7qhH7LiEЩ#{0Z6iQ o	!\iܫCjlon
]ź6#[WUel-)`_W^05ffM]Z,s=..
\HyU3aU`- -DƥҌMH=Sy'L;S.>{$Vg
aDn0rcOT^Z#rK\wc[MĽ]J]rYSc6wǮ`_@׹XW᩻s|1)-p,E'_#|3mf
E{PWm5J*8u/++"MIHC뇎|'9e1i[rsH8}2S=SL
6X Rx|'ybaZŃg};t*TR#
(qb
7@EOT>C|o4VW]TB)F{EiRQ)wPx7GxK݇	:":J)S־rx|SE[v^Tk'Iz
UMEw}
Ek?FO_9MZ[4MS9ҿcӤ:UvKՋB=T Y
@zvPztQ=R

b]XwCO] t+Rz=@B!AW	]%W?L8oSRWla;h"0(UCj*Q}4LQd-.QrrCޥZ@q|ˊPm&c*2fy%OS!qfyHU:CO:; HdlYcISPih.-v+v}pyo63.!@]"uiUjۇa
]EvϺN'4fsP{ÞY]^P{'egIS
uҜ9s.,rنl_9d7]
sP9ZD1",,Hnۿ1y|WB=1;YVG+/h.S;{6FӋ%ZHh][eYu^#ZGSSb̑	wsvBj(W]N=+/j5
_oì=ƏJ3pKnH___TWW _UO98>uڼu֟+Eahn횦	hi`~η;kIvTE~x1
mW"PRӧ鼒f\Wo\WKg}8XiTFƿ}~cSѤ㎿Lu8}_mӴ=;~cTUGd#HD}!fgb4ݱȄ3#OAK=d+]6ٚ(sQ!5:`?z1"#P&%GÒ
\QŦf5.rhߡU(pP#PK
h1M't?R{18\˄m'#▲CiߦOcxޘ<&a0Tb8ڣdLDޙPլ#AC_|UVOONy~^s3WO%}K~E
FL^P:FʚkaP
RTE	1;5h*Ix/EPK
h<4T0org/junit/runners/Parameterized$Parameters.classJ1kתAD=x0x$bRW/:lVB}4>%^ZBIf'/`W |
7;mHWNz8^tͼ:CHX laJ6U`hό͸ ?soB<~̙s9=i/ g0HiV^]|R*ǵXG:>ֱ(!!7
§>%&(
p(I+Xq`qV\x8[)/q'9'sֺþS"8CxzUZ^)_Zvw"`^xN"H]:wO:t<0nڵ 7;MĶ/x&m]#kJMe8:σP\ͬTsNSQ=4susEp`(a8̜ޭl500.ޱZ^e8S9UJ
[p+2(mo/UB
%G;xt s&^V,z+Jĥ8ߩqnzFfrp_t4)C=ۡZ\gr2M9E}֎ًp!|E#o3"
YT5BVC;AՑ)6\{6Ҟ:EǶdrԐꙋB=YW3=q"V+3&l^4qGMxuěxKG`"DEǺ
ܡ4wlO)ziA;Ar4^a\pt^܊OKV	qKk3D:6M:񕉯[঎L@*L&~%H>|TgޣHw*uTu]U‹Wص&j&e};wPFDA4PM/xQV%!Ǟ
`,=[Mm8<Zo2tCײ/RI˶y@_	6{gYY#{6yuKR}Q(KFvûY/%ٮ:-
ל~eUg8^[os8):Lº{\:ʑ܅x\G$;L3Pj!X#tN=DwjH{eyPtb)h
8Ev4N&V&UCzdV|IY3гH-D+QY(=1lVn=D_øb@]쮺+,ja10Px#Kyxo&#CQgqNژirגP=
5ԪcIYplTmɖHP51]IN^W;t]\pI綻PZA[UoNԩK{nH^fp¹F/Ϸy.+ԥ9QtPK
h<\h
%org/junit/runners/Parameterized.classW[Wlp((j`
RbRX%YBMw7ڛ͊Z{ڠkC/j&\گ9svfofΙs?`"i
pLNj=ˇJP Bƨ!	c"\rL ʇIE&,qS"jp'9g씈j𒀗jʦy$iѣ!O*bR/gr>2WЬ28.OɁF!Ujc(T4ي
Ck>njkF[-$`96530Y^T5?>9Ch8eA=$GeCI&SKJs\tt)%L
'/o{Ut*x$L_c&Rmޒe"ãJȲ#vO)59xJ+FÆQ^| [rLdžӗ'Th ޼erWO"ze.NƄco}'Tx9a7Ԇ.C%ܴBDgp^Ae7{Gɡb
zdd9[ӭ|A@RzTg8Ѓ^Ih*iEg%(K؏.	C25ܯ%
xC›xۿ(mC'?{IxQȬ9~$K>>1>p2l[aV%\ႀ>
	F*a6t'.Uơz],>UCu%[D_t.sV'|)+|->4[˄Ns5㪥dIV.dKF)P&c֌܋#	.Q0p$
\]9D q.ZVra1j6O(ӱnSJtaw<ʹ1tNMi(Toڜνd3NZr#ٯL[v((fTB,&_b('6
ڥdNZDhm!%mk?PK
hUnMf
.w.*O֮&eeOYl.vD8qu?

/&ƥe3\u<8/ynB{Κi|GY`t	O
vV@&?-s\VR1T2ViK;-ܥqlv#PK
h<*L&org/junit/runners/ParentRunner$2.classS[OA=ӭ-,b	6vY&,?evdS/i?j	WaSWa..gp9H*q1Zgg(}"
9j\e]C7ƐppLN{ʿU|CYN(ˑ[۸Xx`PK
h<9*&org/junit/runners/ParentRunner$3.classSmkA~wjԗj5jzis-E
B~vsY
K%$
~cTqZcAfna晝㓯#VaRˎS彣5Ȱi6-WýIK𪪒=ScHۤ[0RiL(EBX8z>GoyoCJ:r̵/n^WöX
̣bPG<xDg>2d'ʰ<-Sɨ/YZ14UܶEjn`
+GCVø"}t)'>i5R\DR`O&#x@&XɨN;ZYR3XiAS+<5c:1)H+}c"yKA'nAqnArgneަ4N5܉ewIR<]J1~PK
h<&s
#$org/junit/runners/ParentRunner.classX	x\Uo2yyYKڴM.LI$
iM(2yI^;	3.QwQT%"m-%JQ)+B=7o,$˻w9Y9_n+E[8>w|OH?旟**9U	~
~b&
#zTc*qT1?X?'<)_?fgx<//hxw?W5~VT)E8E@*	M߄³bUx~Q
|*LŹx@动PET߁>=
ؠhHc!=7u(pB	,Dp aD#~s$ƦDb``!=4f	moV"tw,݁8v6@y{Fw鱾0TvG@wkѕ22u9lH@r=!gdIHRĒ<;:"ՙL;nGx$kF񝝥?	JĆ!#"!wcq4aF<ęI!=tA`SvDG%IL[]ŴjI9'lH4aA3z=ZdӤ$kqܶ)Ucn}6L:EqHH3{3yOE.KBmtWhWlpʒ쳰32=nRNv6hl (lQ$8"dhi=yP@0:+b}=ȲTQ3ee*b3
8 ]lkNN
P4'%bM9%xd)j>#1^ti+v^F٤SD%YaA]Cw_iRזV$+dN[1-sUe
)o0J=<\Xz1#2H4(K'VYNˈ̑ HEA3+*9RűՈM#+{wQz.-D|F&##zhzI83 {q5tm#~V/Ҕ㹚8uS VSLdFRE3yTV(+߮Z/p2tbVk=Y=*3sfVFV_nLavO|(:m I3I3Ztx$ ӻna,SrVyTxT
zY3~N1;j"F|͟A76]'P;YL^tb(Bڇ??wB![5unftO玓݄շ7uC,)XGe[>`tN[#Qٮs4YP!l
o,뚲~SY2H@T2QwaG^nPɝ@ȑ9RB\C
	
q]Go4.GW{EG!pӢr4C=ZA!@Py1YZPUE؀~:7j.M&e-@sKB\\h|w*Aﻱ~5/{,%U(u&rRFS^eCB#iЫlr@DR?gxxڼPAbgj\'P)^TStUףg`f]f~M^`B9:/‡YExnOѬ4}!.g>v,5[TJ?ϥf[V'h%kq?3On%+|ľe8
ILj!<Wڠ[	6Z-
oQ yHGEȑ ܶD7DM3Aq4
s1]8InṄ7@:2:y8BC(E(,QPL	/8Yoe6,y6dzq1N?3NlC'W$i
JUK5LxlZsq6|/Ht|~-RhMw۶]:)eK,{(r'
{003ER4;!KdtG
&
$ySFg&BP.+lY+lTȧpK&J8>)6SvUx[z*>ZKtKV:$iTsM78!ɪIsqܙ\g:u]rb܅q{{qSΛ6orb%>wS7eS&Y$M6[r6jPػ[hx9PK
hM8;{'KF!ڲp BZ'0r45q?sYYTzid#YRȱ<UV9X|zExo^hP6wAB챕A.PK
h<t,W)${Xbˈ?:eHυCC77"NdymC_
yAF/%A^$nBR/\rZ&%?el|iG4".ډx-8L*`⢢~޽(8qLxA8L~Bq ;OK6=A2  ͸xhQѷzM1,˱ڗ"a_Lah?8H{eoStL&9$eZ@BڗCI_/J̈3q(	|.1#d]`pM1Mд7L}N	Mż[ƖllIrɾM򬗮3jF,}jq1H8pM¸Dr]B炷Л'sKVr?UUӔeyGՄK&pQBƅͽBNʸE<"-[!pU)7ꧽ-0@^xL
~RPK
hv
*$%:CY
zoPK
h<
;/org/junit/runners/model/FrameworkMethod$1.classSmoP~. X
sm
[%F]bȖF%Kwe܂s~?~(Y+SAKx6ȣPdHka}nJ4w#D{3d>̓ăv
5kcsf=< {qz'oDrK`{[O!V!{Tv^!:oHJt-.g0g^U+ Iqreթ3Ktu|
%
[dAK
!/&a|t{%lTv*ĶK4b
u\U	$u\#G:vXOQ,\k;.-k.o6N:RGctUJe	ߟdƐzsOa6,oSU=y~5Ѽ.l?-0/\M4;)scKS7Ҏm1U;JEkjVe_a44K5+V͚TV؊b,a<4ó,hXDIiLw#)L}!Gq#(Y;7L^.vyW1UD0%d,!IHOV\0
1ڐwم
Q([6sKH$_H68\SWtfv$'m8&VVWX͕Mgq(A2G-;WIHdWdE[|R3g/_	Q<	Ljʑpw`St	6Kn	y
>K8j		J=DfCëֱ)(iO3 Q~'h1uc;UAa'qT}t'e
c>?\GCQ_Gn]C)}\|ԱegE#kAɱ,Z| <ۧ$tf\쟿?~XcJI$QN2Q]TVƽ5}`HW=4y/q>Ɛx_ғ>!]aɆqyJ2=v=}䭞"N0W,7bUe+^-!w!W9:cCͭ=ٱ!2t]gO&	v>k11T?Izxؚl4ABifPCt܎>+Sq|GU$J)O9Oᅲ-9Jwa29O!,Tޥ)OmqThY-3\Cf=VDJ~H
+q1Z]Ѧ49ܠ?U8)id_v1::ϓ
MfU!rDVyZ/$elpEJ&S蜢}ɍ]hU՞#Y+h>G:7]%CՎeGX)!k:TYi'J>MR.R{KcewSSXlmq+"_FTv5@m|H3P[$}ZPK
h<[+org/junit/runners/model/RunnerBuilder.classVM[U~'L2tVB &- -A0ag&U\wMy<;B}E9ɟUhT&-L|V0
wp3
JU9̫*Tx<G
ƤxRhKP6uװ}O±u/~Q‘j~5$ןn[dGIJhI;ˆ6mcdEIS֭95{$5LS_(VlpqL6V1eåxq3"ګ7)ش7؊^g+
I ͮ">QHYLw3jӗ,FH?{HMi<5|u7jǟlM
%tݔ鉦l-70
0*:rhnxvz^U׸2l.҄Wm[f3kdWKN-fp.Ћ}[okC&ׅr߯ikVup]ǝ167Эpa46E&(2uV7?@p,Ot*xdmL{tom
ʎL3TbFtGqgiV
V4bMaOAK
ypkez2"9o4
%4ިcHãuӜӚUP}x
12#,G.gq7t:iXln((?o?E_\O-wєD+.%h8݁Ela-?C~h^dq;-{8Ȓh\jLI">/_kG6ۻPr;h4KPAk@e2D
t΃]ji>a4*DOsH?.ԅ6wh-wwpUn(1ԉJ%?,TDPˍ'=WE098pƫVBK]GQ$εWԡc>tN}vA6=+*%E.$6
x:jmX%A쮰ZH7JHxViԌao\f_&o禇^^[.œ#%
lON=..=fE=!=?b+ThV[g9z~@>kNG\c5nb  ~8aus/PK
h<?
'org/junit/runners/model/TestClass.classW~:V76v,AH6.1↜nljBB)l䵭 KjW --%4MKm)Pچ؄=3,)_;;;{<;̾Gd|؏JGDQ?c>Ç|:|ͣ2>))?yBƤ|Ə'TY1}^hhN|QƗX#Yќ1%cZxSb~32^O	/	'2">|͏N<,2^ِRY	}սjGJMvC%%GӪ5	ͥݑ5i׌p'K3j$3iksF2ѯNP֙#ݕ%Fw_F؝K'=Nkzc<3:ztu\ۗo̯^ZxIjrgn6mٖIJ!N2 odZȍ+őLBMmS"ZPFRZ谣^UחH
4^	5Ivjz{	
h."z
MW.cI.>/q-kse& &)CVM۬3Qp5#rX͌4-A7%

$,,rLu(8DE7U!䵌IX^\ꄄeD/j2u.%.a

;6{UK7)6{T3aXvey:
0م\5OxPEhj}DBAnғ߁îbg&ȌWdf	.1'@hrn.k'Ces)aslj]d`	tE=+k:u`OmC%x]g握"WIB+_Dxl[bb]8Sӷpn)'EE6%Z6iB}nQR"7^Y^Z~tpa͞o29=$-޹\%ūVnVc*ѭ`h*kDh}47΍@MPB%t(Ê{5PQ%+bT7-V|W}RHI
~JXVQ#H6lWcD/T܃{w(Ha\/K_ע9+7
~$
w?D}ffx*8^蚂?	Eq;?e:J)wo\Z]x6ᕸ 2Kqh͙}p:CߧtH
>\j8HpҍZXwAa-=/._ΗE4^zo*%mNc&;,!~-]Uv>Hi4<ͭҚKօP\qAIf>mxqRRto9F|ef\$ԑ35^єk"gMʹ4Rr\đtPx%q'&aluTfg޲JY]\h
	oW
b|H)
k$q4i옆$܅'=	oD q?YT;
ȳN	m0K1e^Khhe1w}cXt16wi4Q{zsgK.8K&zcنXp9Z	,B؎e<&8}	D1K
vc7ofj54\rm#Oæ:r9r1L
-ސ8-cbNʇ琝0%j93~<cmx:cޠ.ϩich7cp?#WCC犞\&}Σ=vk~bѼdZ*r8-ոs2ÜbR&zPlpyDT>;vBDV1P޲:v,0-4`B6]fQs‰khFbI91dK1Ĉ(V<_2a[XjY_hn),taXT2_\_o!%n8~,1̞eSܰ3:8zcv+B5:Kpqbo){ 'v=]ȍE:bO	"b'(n(G_Acev6sl+`J`5X;~V[=nvQ|7>^ZS~B*Hw޶>quDd'L,MG=#;9ƻfZJz_i	ћBJn.e47ٚ%RHlK珞9DjE潻(m>]xwQ89</v =v V >hCi/
r/u*
	ks>#mSVyȢ17X8|;VL'Ͻt(ܵ$	~<#=L?$5=7뙂4,~&<'ǔW o6hCYu]T&gpvQB0=h>oPK
h<	AMETA-INF/PK
h<S_+META-INF/MANIFEST.MFPK
h<Ajunit/PK
h<Ajunit/extensions/PK
h<Ajunit/framework/PK
h<
A1junit/runner/PK
h<
A\junit/textui/PK
yp6Aorg/PK
h<
Aorg/hamcrest/PK
h<Aorg/hamcrest/core/PK
h<Aorg/hamcrest/internal/PK
h<
A8org/junit/PK
h<A`org/junit/experimental/PK
h<"Aorg/junit/experimental/categories/PK
h<Aorg/junit/experimental/max/PK
h<Aorg/junit/experimental/results/PK
h<AKorg/junit/experimental/runners/PK
h< Aorg/junit/experimental/theories/PK
h<)Aorg/junit/experimental/theories/internal/PK
h<*A
org/junit/experimental/theories/suppliers/PK
h<AUorg/junit/internal/PK
h<Aorg/junit/internal/builders/PK
h<Aorg/junit/internal/matchers/PK
h<Aorg/junit/internal/requests/PK
h<A4org/junit/internal/runners/PK
h<!Amorg/junit/internal/runners/model/PK
h<&Aorg/junit/internal/runners/statements/PK
h<Aorg/junit/matchers/PK
h<A!org/junit/rules/PK
h<AOorg/junit/runner/PK
h<A~org/junit/runner/manipulation/PK
h<Aorg/junit/runner/notification/PK
h<Aorg/junit/runners/PK
h<A&org/junit/runners/model/PK
yp6s!!\LICENSE.txtPK
h<P(
junit/extensions/ActiveTestSuite$1.classPK
h<`ǫ&junit/extensions/ActiveTestSuite.classPK
h<d<#junit/extensions/RepeatedTest.classPK
hV9f@junit/framework/Test.classPK
h<<99
3Ajunit/framework/TestCase.classPK
h<0q2Q8!Gjunit/framework/TestFailure.classPK
hV!porg/junit/ComparisonFailure.classPK
h<org/junit/Ignore.classPK
horg/junit/Test$None.classPK
hGe:!org/junit/experimental/max/MaxHistory$TestComparator.classPK
h<+%org/junit/experimental/max/MaxHistory.classPK
h<@@0,org/junit/experimental/results/FailureList.classPK
h<{|40org/junit/experimental/results/PrintableResult.classPK
h-?org/junit/experimental/runners/Enclosed.classPK
h<4J7/Aorg/junit/experimental/theories/DataPoint.classPK
hV,rorg/junit/experimental/theories/internal/AllMembersSupplier$MethodParameterValue.classPK
h<ڇZA"vorg/junit/experimental/theories/internal/AllMembersSupplier.classPK
h d(org/junit/internal/matchers/Each$1.classPK
h<;*&org/junit/internal/matchers/Each.classPK
h4org/junit/internal/runners/TestMethod.classPK
h78org/junit/internal/runners/model/EachTestNotifier.classPK
horg/junit/runners/BlockJUnit4ClassRunner.classPK
h&1 |
    grep -q 'model contains [0-9]* documentable templates'
scala  -classpath $CLASSPATH AtdsTest > scala.trace || {
    cat scala.trace
    exit 1
}
atd-2.1.0/atds/test/test.atd000066400000000000000000000026401357165332000156540ustar00rootroot00000000000000(* Sum (enum) *)
type e = [ Alpha | Beta ]

type es = e list

(* Record with optional field *)
type simple_record = {
  int_field: int;
  ?opt : bool option
}


(* Sum *)
type sample_sum = [
  | Simple_tag
  | Bool of bool
  | Int  of int
  | Float of float
  | String  of string
  | Simple_rec of simple_record
  | Complex_record of complex_record
  | Record_with_defaults of record_with_defaults
]


(* Record *)
type complex_record = {
  b  : bool;
  i : int;
  s : string;
  l : bool list;
  m : int list list;
  sample_sum : sample_sum;

  (* Scala keywords used as field names *)
  ?class : int option;
  ?final  : int option;
  case  : string;

  (* List of records *)
  l2 : record_with_defaults list;
}


(* Record with default fields *)
type record_with_defaults = {
  ~b : bool;
  ~i : int;
  ~s : string;
  ~o : bool option;
  ~l : bool list;
  ~e : e;
  }

type bigger_record = {
  inherit record_with_defaults;
  more : string;
}

(* type alias *)
type rec = record_with_defaults
type rwd  = record_with_defaults

type bigger_sum = [
  inherit e
  | Gamma
]

type street = (int * string)
type city = string
type state = string

type addr = {
  street: street;
  city: city;
  state: state;
}

(*
(* https://github.com/esperco/atdj/issues/2 *)
type a = [ A of b list ]
type b = [ B ]
*)
atd-2.1.0/atds/test/test.expected.scala000066400000000000000000000116671357165332000200000ustar00rootroot00000000000000// Automatically generated; do not edit
package com.mylife

import argonaut._, Argonaut._

package object test {

/**
 * Common utility interface.
 */
trait Atds {

  /**
   * Get the Argonaut JSON representation.
   * Please use the argonaut encoder rather than calling this directly.
   */
  protected def toArgonaut: argonaut.Json

  // These may be optimized later, and the dependency on Argonaut could be removed.

  /**
   * Get the JSON string representation.
   * @return The JSON string.
   */
  def toJson: String = toArgonaut.nospaces

  /**
   * Write the JSON representation to a buffer.
   */
  def toJsonBuffer(out: java.lang.StringBuilder): Unit = out.append(toJson)

}

object Atds {

  implicit def argonautCodecAtds[A <: Atds] = new argonaut.EncodeJson[A] {
    override def encode(a: A) = a.toArgonaut
  }

}

/**
 * Construct objects of type e.
 */
sealed abstract class E extends Atds

/**
 * Define tags for sum type e.
 */
object E {
  case object Alpha extends E {
    override protected def toArgonaut: argonaut.Json = jString("Alpha")
  }
  case object Beta extends E {
    override protected def toArgonaut: argonaut.Json = jString("Beta")
  }
}

type Es = List[E]

case class SimpleRecord(
  int_field : Int,
  opt : Option[Boolean],
) extends Atds {

  override protected def toArgonaut: Json = Json(
    "int_field" := int_field,
    "opt" := opt,
  )
}

/**
 * Construct objects of type sample_sum.
 */
sealed abstract class SampleSum extends Atds

/**
 * Define tags for sum type sample_sum.
 */
object SampleSum {
  case object SimpleTag extends SampleSum {
    override protected def toArgonaut: argonaut.Json = jString("Simple_tag")
  }
  case class Bool(data: Boolean) extends SampleSum {
    override protected def toArgonaut: argonaut.Json = argonaut.Json.array(
      jString("Bool"),
      data.asJson
     )
  }
  case class Integer(data: Int) extends SampleSum {
    override protected def toArgonaut: argonaut.Json = argonaut.Json.array(
      jString("Int"),
      data.asJson
     )
  }
  case class Float(data: Double) extends SampleSum {
    override protected def toArgonaut: argonaut.Json = argonaut.Json.array(
      jString("Float"),
      data.asJson
     )
  }
  case class S(data: String) extends SampleSum {
    override protected def toArgonaut: argonaut.Json = argonaut.Json.array(
      jString("String"),
      data.asJson
     )
  }
  case class SimpleRec(data: SimpleRecord) extends SampleSum {
    override protected def toArgonaut: argonaut.Json = argonaut.Json.array(
      jString("Simple_rec"),
      data.asJson
     )
  }
  case class ComplexRecord(data: ComplexRecord) extends SampleSum {
    override protected def toArgonaut: argonaut.Json = argonaut.Json.array(
      jString("Complex_record"),
      data.asJson
     )
  }
  case class RecordWithDefaults(data: RecordWithDefaults) extends SampleSum {
    override protected def toArgonaut: argonaut.Json = argonaut.Json.array(
      jString("Record_with_defaults"),
      data.asJson
     )
  }
}

/**
 * wibble
 */
case class ComplexRecord(
  b : Boolean,
  i : Int,
  s : String,
  l : List[Boolean],
  m : List[List[Int]],
  sample_sum : SampleSum,
  class_ : Option[Int],
  final_ : Option[Int],
  kase : String,
  l2 : List[RecordWithDefaults],
) extends Atds {

  override protected def toArgonaut: Json = Json(
    "b" := b,
    "i" := i,
    "s" := s,
    "l" := l,
    "m" := m,
    "sample_sum" := sample_sum,
    "class" := class_,
    "final" := final_,
    "case" := kase,
    "l2" := l2,
  )
}

case class RecordWithDefaults(
  b : Boolean = false,
  i : Int = 0,
  s : String = "",
  o : Option[Boolean] = None,
  l : List[Boolean] = Nil,
  e : E,
) extends Atds {

  override protected def toArgonaut: Json = Json(
    "b" := b,
    "i" := i,
    "s" := s,
    "o" := o,
    "l" := l,
    "e" := e,
  )
}

case class BiggerRecord(
  b : Boolean = false,
  i : Int = 0,
  s : String = "",
  o : Option[Boolean] = None,
  l : List[Boolean] = Nil,
  e : E,
  more : String,
) extends Atds {

  override protected def toArgonaut: Json = Json(
    "b" := b,
    "i" := i,
    "s" := s,
    "o" := o,
    "l" := l,
    "e" := e,
    "more" := more,
  )
}

type Rec = RecordWithDefaults

type RWD = RecordWithDefaults

/**
 * Construct objects of type bigger_sum.
 */
sealed abstract class BiggerSum extends Atds

/**
 * Define tags for sum type bigger_sum.
 */
object BiggerSum {
  case object Alpha extends BiggerSum {
    override protected def toArgonaut: argonaut.Json = jString("Alpha")
  }
  case object Beta extends BiggerSum {
    override protected def toArgonaut: argonaut.Json = jString("Beta")
  }
  case object Gamma extends BiggerSum {
    override protected def toArgonaut: argonaut.Json = jString("Gamma")
  }
}

type Street = (Int, String)

type City = String

type State = String

case class Addr(
  street : Street,
  city : String,
  state : String,
) extends Atds {

  override protected def toArgonaut: Json = Json(
    "street" := street,
    "city" := city,
    "state" := state,
  )
}

}
atd-2.1.0/doc/000077500000000000000000000000001357165332000130345ustar00rootroot00000000000000atd-2.1.0/doc/atdgen.rst000066400000000000000000001320121357165332000150270ustar00rootroot00000000000000****************
Atdgen reference
****************

Description
===========

Atdgen is a command-line program that takes as input type definitions in
the `ATD syntax `__ and produces OCaml code
suitable for data serialization and deserialization.

Two data formats are currently supported, these are
`JSON `__ and
`biniou `__, a binary format with
extensibility properties similar to JSON. Atdgen-json and Atdgen-biniou
will refer to Atdgen used in one context or the other.

Atdgen was designed with efficiency and durability in mind. Software
authors are encouraged to use Atdgen directly and to write tools that
may reuse part of Atdgen's source code.

Atdgen uses the following packages that were developed in conjunction
with Atdgen:

-  ``atd``: parser for the syntax of type definitions
-  ``biniou``: parser and printer for biniou, a binary extensible data
   format
-  ```yojson`` `__: parser and printer
   for JSON, a widespread text-based data format

Command-line usage
==================

Command-line help
-----------------

Call ``atdgen -help`` for the full list of available options.

Atdgen-json example
-------------------

::

    $ atdgen -t example.atd
    $ atdgen -j -j-std example.atd

Input file ``example.atd``:

.. code:: ocaml

    type profile = {
      id : string;
      email : string;
      ~email_validated : bool;
      name : string;
      ?real_name : string option;
      ~about_me : string list;
      ?gender : gender option;
      ?date_of_birth : date option;
    }

    type gender = [ Female | Male ]

    type date = {
      year : int;
      month : int;
      day : int;
    }

is used to produce files ``example_t.mli``, ``example_t.ml``,
``example_j.mli`` and ``example_j.ml``. This is ``example_j.mli``:

.. code:: ocaml

    (* Auto-generated from "example.atd" *)


    type gender = Example_t.gender

    type date = Example_t.date = { year: int; month: int; day: int }

    type profile = Example_t.profile = {
      id: string;
      email: string;
      email_validated: bool;
      name: string;
      real_name: string option;
      about_me: string list;
      gender: gender option;
      date_of_birth: date option
    }

    val write_gender :
      Bi_outbuf.t -> gender -> unit
      (** Output a JSON value of type {!gender}. *)

    val string_of_gender :
      ?len:int -> gender -> string
      (** Serialize a value of type {!gender}
          into a JSON string.
          @param len specifies the initial length
                     of the buffer used internally.
                     Default: 1024. *)

    val read_gender :
      Yojson.Safe.lexer_state -> Lexing.lexbuf -> gender
      (** Input JSON data of type {!gender}. *)

    val gender_of_string :
      string -> gender
      (** Deserialize JSON data of type {!gender}. *)

    val write_date :
      Bi_outbuf.t -> date -> unit
      (** Output a JSON value of type {!date}. *)

    val string_of_date :
      ?len:int -> date -> string
      (** Serialize a value of type {!date}
          into a JSON string.
          @param len specifies the initial length
                     of the buffer used internally.
                     Default: 1024. *)

    val read_date :
      Yojson.Safe.lexer_state -> Lexing.lexbuf -> date
      (** Input JSON data of type {!date}. *)

    val date_of_string :
      string -> date
      (** Deserialize JSON data of type {!date}. *)

    val write_profile :
      Bi_outbuf.t -> profile -> unit
      (** Output a JSON value of type {!profile}. *)

    val string_of_profile :
      ?len:int -> profile -> string
      (** Serialize a value of type {!profile}
          into a JSON string.
          @param len specifies the initial length
                     of the buffer used internally.
                     Default: 1024. *)

    val read_profile :
      Yojson.Safe.lexer_state -> Lexing.lexbuf -> profile
      (** Input JSON data of type {!profile}. *)

    val profile_of_string :
      string -> profile
      (** Deserialize JSON data of type {!profile}. *)

Module ``Example_t`` (files ``example_t.mli`` and ``example_t.ml``)
contains all OCaml type definitions that can be used independently from
Biniou or JSON.

For convenience, these definitions are also made available from the
``Example_j`` module whose interface is shown above. Any type name,
record field name or variant constructor can be referred to using either
module. For example, the OCaml expressions
``((x : Example_t.date) : Example_j.date)`` and
``x.Example_t.year = x.Example_j.year`` are both valid.

Atdgen-biniou example
---------------------

::

    $ atdgen -t example.atd
    $ atdgen -b example.atd

Input file ``example.atd``:

.. code:: ocaml

    type profile = {
      id : string;
      email : string;
      ~email_validated : bool;
      name : string;
      ?real_name : string option;
      ~about_me : string list;
      ?gender : gender option;
      ?date_of_birth : date option;
    }

    type gender = [ Female | Male ]

    type date = {
      year : int;
      month : int;
      day : int;
    }

is used to produce files ``example_t.mli``, ``example_t.ml``,
``example_b.mli`` and ``example_b.ml``.

This is ``example_b.mli``:

.. code:: ocaml

    (* Auto-generated from "example.atd" *)


    type gender = Example_t.gender

    type date = Example_t.date = { year: int; month: int; day: int }

    type profile = Example_t.profile = {
      id: string;
      email: string;
      email_validated: bool;
      name: string;
      real_name: string option;
      about_me: string list;
      gender: gender option;
      date_of_birth: date option
    }

    (* Writers for type gender *)

    val gender_tag : Bi_io.node_tag
      (** Tag used by the writers for type {!gender}.
          Readers may support more than just this tag. *)

    val write_untagged_gender :
      Bi_outbuf.t -> gender -> unit
      (** Output an untagged biniou value of type {!gender}. *)

    val write_gender :
      Bi_outbuf.t -> gender -> unit
      (** Output a biniou value of type {!gender}. *)

    val string_of_gender :
      ?len:int -> gender -> string
      (** Serialize a value of type {!gender} into
          a biniou string. *)

    (* Readers for type gender *)

    val get_gender_reader :
      Bi_io.node_tag -> (Bi_inbuf.t -> gender)
      (** Return a function that reads an untagged
          biniou value of type {!gender}. *)

    val read_gender :
      Bi_inbuf.t -> gender
      (** Input a tagged biniou value of type {!gender}. *)

    val gender_of_string :
      ?pos:int -> string -> gender
      (** Deserialize a biniou value of type {!gender}.
          @param pos specifies the position where
                     reading starts. Default: 0. *)

    (* Writers for type date *)

    val date_tag : Bi_io.node_tag
      (** Tag used by the writers for type {!date}.
          Readers may support more than just this tag. *)

    val write_untagged_date :
      Bi_outbuf.t -> date -> unit
      (** Output an untagged biniou value of type {!date}. *)

    val write_date :
      Bi_outbuf.t -> date -> unit
      (** Output a biniou value of type {!date}. *)

    val string_of_date :
      ?len:int -> date -> string
      (** Serialize a value of type {!date} into
          a biniou string. *)

    (* Readers for type date *)

    val get_date_reader :
      Bi_io.node_tag -> (Bi_inbuf.t -> date)
      (** Return a function that reads an untagged
          biniou value of type {!date}. *)

    val read_date :
      Bi_inbuf.t -> date
      (** Input a tagged biniou value of type {!date}. *)

    val date_of_string :
      ?pos:int -> string -> date
      (** Deserialize a biniou value of type {!date}.
          @param pos specifies the position where
                     reading starts. Default: 0. *)

    (* Writers for type profile *)

    val profile_tag : Bi_io.node_tag
      (** Tag used by the writers for type {!profile}.
          Readers may support more than just this tag. *)

    val write_untagged_profile :
      Bi_outbuf.t -> profile -> unit
      (** Output an untagged biniou value of type {!profile}. *)

    val write_profile :
      Bi_outbuf.t -> profile -> unit
      (** Output a biniou value of type {!profile}. *)

    val string_of_profile :
      ?len:int -> profile -> string
      (** Serialize a value of type {!profile} into
          a biniou string. *)

    (* Readers for type profile *)

    val get_profile_reader :
      Bi_io.node_tag -> (Bi_inbuf.t -> profile)
      (** Return a function that reads an untagged
          biniou value of type {!profile}. *)

    val read_profile :
      Bi_inbuf.t -> profile
      (** Input a tagged biniou value of type {!profile}. *)

    val profile_of_string :
      ?pos:int -> string -> profile
      (** Deserialize a biniou value of type {!profile}.
          @param pos specifies the position where
                     reading starts. Default: 0. *)

Module ``Example_t`` (files ``example_t.mli`` and ``example_t.ml``)
contains all OCaml type definitions that can be used independently from
Biniou or JSON.

For convenience, these definitions are also made available from the
``Example_b`` module whose interface is shown above. Any type name,
record field name or variant constructor can be referred to using either
module. For example, the OCaml expressions
``((x : Example_t.date) : Example_b.date)`` and
``x.Example_t.year = x.Example_b.year`` are both valid.

Validator example
-----------------

::

    $ atdgen -t example.atd
    $ atdgen -v example.atd

Input file ``example.atd``:

.. code:: ocaml

    type month = int 
    type day = int 

    type date = {
      year : int;
      month : month;
      day : day;
    }
      

is used to produce files ``example_t.mli``, ``example_t.ml``,
``example_v.mli`` and ``example_v.ml``. This is ``example_v.ml``,
showing how the user-specified validators are used:

.. code:: ocaml

    (* Auto-generated from "example.atd" *)


    type gender = Example_t.gender

    type date = Example_t.date = { year: int; month: int; day: int }

    type profile = Example_t.profile = {
      id: string;
      email: string;
      email_validated: bool;
      name: string;
      real_name: string option;
      about_me: string list;
      gender: gender option;
      date_of_birth: date option
    }

    val validate_gender :
      Atdgen_runtime.Util.Validation.path -> gender -> Atdgen_runtime.Util.Validation.error option
      (** Validate a value of type {!gender}. *)

    val create_date :
      year: int ->
      month: int ->
      day: int ->
      unit -> date
      (** Create a record of type {!date}. *)

    val validate_date :
      Atdgen_runtime.Util.Validation.path -> date -> Atdgen_runtime.Util.Validation.error option
      (** Validate a value of type {!date}. *)

    val create_profile :
      id: string ->
      email: string ->
      ?email_validated: bool ->
      name: string ->
      ?real_name: string ->
      ?about_me: string list ->
      ?gender: gender ->
      ?date_of_birth: date ->
      unit -> profile
      (** Create a record of type {!profile}. *)

    val validate_profile :
      Atdgen_runtime.Util.Validation.path -> profile -> Atdgen_runtime.Util.Validation.error option
      (** Validate a value of type {!profile}. *)

Default type mapping
====================

The following table summarizes the default mapping between ATD types and
OCaml, biniou and JSON data types. For each language more
representations are available and are detailed in the next section of
this manual.

+-----------------+---------------------+-------------------+--------------------+
| ATD             | OCaml               | JSON              | Biniou             |
+=================+=====================+===================+====================+
| ``unit``        | ``unit``            | null              | unit               |
+-----------------+---------------------+-------------------+--------------------+
| ``bool``        | ``bool``            | boolean           | bool               |
+-----------------+---------------------+-------------------+--------------------+
| ``int``         | ``int``             | -?(0\|[1-9][0-9]\ | svint              |
|                 |                     | *)                |                    |
+-----------------+---------------------+-------------------+--------------------+
| ``float``       | ``float``           | number            | float64            |
+-----------------+---------------------+-------------------+--------------------+
| ``string``      | ``string``          | string            | string             |
+-----------------+---------------------+-------------------+--------------------+
| ``'a option``   | ``'a option``       | ``"None"`` or     | numeric variants   |
|                 |                     | ``["Some", ...]`` | (tag 0)            |
+-----------------+---------------------+-------------------+--------------------+
| ``'a nullable`` | ``'a option``       | ``null`` or       | numeric variants   |
|                 |                     | representation of | (tag 0)            |
|                 |                     | ``'a``            |                    |
+-----------------+---------------------+-------------------+--------------------+
| ``'a list``     | ``'a list``         | array             | array              |
+-----------------+---------------------+-------------------+--------------------+
| ``'a shared``   | no wrapping         | not implemented   | no longer          |
|                 |                     |                   | supported          |
+-----------------+---------------------+-------------------+--------------------+
| ``'a wrap``     | defined by          | representation of | representation of  |
|                 | annotation,         | ``'a``            | ``'a``             |
|                 | converted from      |                   |                    |
|                 | ``'a``              |                   |                    |
+-----------------+---------------------+-------------------+--------------------+
| variants        | polymorphic         | variants          | regular variants   |
|                 | variants            |                   |                    |
+-----------------+---------------------+-------------------+--------------------+
| record          | record              | object            | record             |
+-----------------+---------------------+-------------------+--------------------+
| ``('a * 'b)``   | ``('a * 'b)``       | array             | tuple              |
+-----------------+---------------------+-------------------+--------------------+
| ``('a)``        | ``'a``              | array             | tuple              |
+-----------------+---------------------+-------------------+--------------------+

Notes:

-  Null JSON fields by default are treated as if the field was missing.
   They can be made meaningful with the ``keep_nulls`` flag.
-  JSON nulls are used to represent the unit value and is useful for
   instanciating parametrized types with "nothing".
-  OCaml floats are written to JSON numbers with either a decimal point
   or an exponent such that they are distinguishable from ints, even
   though the JSON standard does not require a distinction between the
   two.
-  The optional values of record fields denoted in ATD by a question
   mark are unwrapped or omitted in both biniou and JSON.
-  JSON option values and JSON variants are represented in standard JSON
   (``atdgen -j -j-std``) by a single string e.g. ``"None"`` or a pair
   in which the first element is the name (constructor) e.g.
   ``["Some", 1234]``. Yojson also provides a specific syntax for
   variants using edgy brackets: ``<"None">``, ``<"Some": 1234>``.
-  Biniou field names and variant names other than the option types use
   the hash of the ATD field or variant name and cannot currently be
   overridden by annotations.
-  JSON tuples in standard JSON (``atdgen -j -j-std``) use the array
   notation e.g. ``["ABC", 123]``. Yojson also provides a specific
   syntax for tuples using parentheses, e.g. ``("ABC", 123)``.
-  Types defined as abstract are defined in another module.

ATD Annotations
===============

Section ``json``
------------------

Field ``keep_nulls``
~~~~~~~~~~~~~~~~~~~~~~

Position: after record

Values: none, ``true`` or ``false``

Semantics: this flag, if present or set to true, indicates that fields
whose JSON value is ``null`` should not be treated as if they were
missing. In this case, ``null`` is parsed as a normal value, possibly of
a ``nullable`` type.

Example: patch semantics

.. code:: ocaml

    (* Type of the objects stored in our database *)
    type t = {
      ?x : int option;
      ?y : int option;
      ?z : int option;
    }

.. code:: ocaml

    (* Type of the requests to modify some of the fields of an object. *)
    type t_patch = {
      ?x : int nullable option; (* OCaml type: int option option *)
      ?y : int nullable option;
      ?z : int nullable option;
    }  

Let's consider the following json patch that means "set ``x`` to 1,
clear ``y`` and keep ``z`` as it is":

::

    {
      "x": 1,
      "y": null
    }

It will be parsed by the generated function ``t_patch_of_string`` into
the following OCaml value:

.. code:: ocaml

    {
      patch_x = Some (Some 1);
      patch_y = Some None;
      patch_z = None;
    }

Then presumably some code would be written to apply the patch to an
object of type ``t``. Such code is not generated by atdgen at this time.

Available: from atd 1.12

Field ``name``
~~~~~~~~~~~~~~~~

Position: after field name or variant name

Values: any string making a valid JSON string value

Semantics: specifies an alternate object field name or variant name to
be used by the JSON representation.

Example:

.. code:: ocaml

    type color = [
        Black 
      | White 
      | Grey 
    ]

    type profile = {
      id  : int;
      username : string;
      background_color : color;
    }

A valid JSON object of the ``profile`` type above is:

::

    {
      "ID": 12345678,
      "username": "kimforever",
      "background_color": "black"
    }

Field ``repr``
~~~~~~~~~~~~~~~~

Association lists
^^^^^^^^^^^^^^^^^

Position: after ``(string * _) list`` type

Values: ``object``

Semantics: uses JSON's object notation to represent association lists.

Example:

.. code:: ocaml

    type counts = (string * int) list 

A valid JSON object of the ``counts`` type above is:

::

    {
      "bob": 3,
      "john": 1408,
      "mary": 450987,
      "peter": 93087
    }

Without the annotation ````, the data above would be
represented as:

::

    [
      [ "bob", 3 ],
      [ "john", 1408 ],
      [ "mary", 450987 ],
      [ "peter", 93087 ]
    ]

Floats
^^^^^^

Position: after ``float`` type

Values: ``int``

Semantics: specifies a float value that must be rounded to the nearest
integer and represented in JSON without a decimal point nor an exponent.

Example:

.. code:: ocaml

    type unixtime = float 

Field ``tag_field``
~~~~~~~~~~~~~~~~~~~~~

Superseded by ````. Available since atdgen
1.5.0 and yojson 1.2.0 until atdgen 1.13.

This feature makes it possible to read JSON objects representing
variants that use one field for the tag and another field for the
untagged value of the specific type associated with that tag.

Position: on a record field name, for a field holding a variant type.

Value: name of another JSON field which holds the string representing
the constructor for the variant.

Semantics: The type definition

.. code:: ocaml

    type t = {
      value : [ A | B  of int ];
    }

covers JSON objects that have an extra field ``kind`` which holds either
``"A"`` or ``"b"``. Valid JSON values of type ``t`` include
``{ "kind": "A" }`` and ``{ "kind": "b", "value": 123 }``.

Field ``untyped``
~~~~~~~~~~~~~~~~~~~

Superseded by ```` and ````.
Available since atdgen 1.10.0 and atd 1.2.0 until atdgen 1.13.

This flag enables parsing of arbitrary variants without prior knowledge
of their type. It is useful for constructing flexible parsers for
extensible serializations. ``json untyped`` is compatible with regular
variants, ``json tag_field`` variants, default values, and implicit
``tag_field`` constructors.

Position: on a variant constructor with argument type
``string * json option`` (at most one per variant type)

Value: none, ``true`` or ``false``

Semantics: The type definition

.. code:: ocaml

    type v = [
      | A
      | B  of int
      | Unknown  of (string * json option)
    ]

will parse and print ``"A"``, ``["b", 0]``, ``"foo"``, and
``["bar", [null]]`` in a regular variant context. In the ``tag_field``
type ``t`` context in the previous section, ``v`` will parse and print
``{ "kind": "foo" }`` and ``{ "kind": "bar", "value": [null] }`` as well
as the examples previously given.

Field ``open_enum``
~~~~~~~~~~~~~~~~~~~~~

Where an enum (finite set of strings) is expected, this flag allows
unexpected strings to be kept under a catch-all constructor rather than
producing an error.

Position: on a variant type comprising exactly one constructor with an
argument. The type of that argument must be ``string``. All other
constructors must have no arguments.

Value: none

For example:

.. code:: ocaml

    type language = [
      | English
      | Chinese
      | Other of string
    ] 

maps the json string ``"Chinese"`` to the OCaml value ```Chinese`` and
maps ``"French"`` to ```Other "French"``.

Available since atdgen 2.0.

Field ``adapter.ocaml``
~~~~~~~~~~~~~~~~~~~~~~~~~

Json adapters are a mechanism for rearranging json data on-the-fly, so
as to make them compatible with ATD. The programmer must provide an
OCaml module that provides converters between the original json
representation and the ATD-compatible representation. The signature of
the user-provided module must be equal to
``Atdgen_runtime.Json_adapter.S``, which is:

.. code:: ocaml

    sig
      (** Convert from original json to ATD-compatible json *)
      val normalize : Yojson.Safe.t -> Yojson.Safe.t

      (** Convert from ATD-compatible json to original json *)
      val restore : Yojson.Safe.t -> Yojson.Safe.t
    end

The type ``Yojson.Safe.t`` is the type of parsed JSON as provided by
the yojson library.

Position: on a variant type or on a record type.

Value: an OCaml module identifier. Note that
``Atdgen_runtime.Json_adapter`` provides a few modules and functors that
are ready to use. Users are however encouraged to write their own to
suit their needs.

Sample ATD definitions:

.. code:: ocaml

    type document = [
      | Image of image
      | Text of text
    ] 

    type image = {
      url: string;
    }

    type text = {
      title: string;
      body: string;
    }

ATD-compliant json values:

-  ``["Image", {"url": "https://example.com/ocean123.jpg"}]``
-  ``["Text", {"title": "Cheeses Around the World", "body": "..."}]``

Corresponding json values given by some API:

-  ``{"type": "Image", "url": "https://example.com/ocean123.jpg"}``
-  ``{"type": "Text", "title": "Cheeses Around the World", "body": "..."}``

The json adapter ``Type_field`` that ships with the atdgen runtime takes
care of converting between these two forms. For information on how to
write your own adapter, please consult the documentation for the yojson
library.

Section ``biniou``
--------------------

Field ``repr``
~~~~~~~~~~~~~~~~

Integers
^^^^^^^^

Position: after ``int`` type

Values: ``svint`` (default), ``uvint``, ``int8``, ``int16``, ``int32``,
``int64``

Semantics: specifies an alternate type for representing integers. The
default type is ``svint``. The other integers types provided by biniou
are supported by Atdgen-biniou. They have to map to the corresponding
OCaml types in accordance with the following table:

+---------------+------------------------+---------------------------------------+
| Biniou type   | Supported OCaml type   | OCaml value range                     |
+===============+========================+=======================================+
| ``svint``     | ``int``                | ``min_int`` ... ``max_int``           |
+---------------+------------------------+---------------------------------------+
| ``uvint``     | ``int``                | 0 ... ``max_int``, ``min_int`` ... -1 |
+---------------+------------------------+---------------------------------------+
| ``int8``      | ``char``               | ``'\000`` ... ``'\255``             |
+---------------+------------------------+---------------------------------------+
| ``int16``     | ``int``                | 0 ... 65535                           |
+---------------+------------------------+---------------------------------------+
| ``int32``     | ``int32``              | ``Int32.min_int`` ...                 |
|               |                        | ``Int32.max_int``                     |
+---------------+------------------------+---------------------------------------+
| ``int64``     | ``int64``              | ``Int64.min_int`` ...                 |
|               |                        | ``Int64.max_int``                     |
+---------------+------------------------+---------------------------------------+

In addition to the mapping above, if the OCaml type is ``int``, any
biniou integer type can be read into OCaml data regardless of the
declared biniou type.

Example:

.. code:: ocaml

    type t = {
      id : int
        
        ;
      data : string list;
    }

Floating-point numbers
^^^^^^^^^^^^^^^^^^^^^^

Position: after ``float`` type

Values: ``float64`` (default), ``float32``

Semantics: ``float32`` allows for a shorter serialized representation of
floats, using 4 bytes instead of 8, with reduced precision. OCaml floats
always use 8 bytes, though.

Example:

.. code:: ocaml

    type t = {
      lat : float ;
      lon : float ;
    }

Arrays and tables
^^^^^^^^^^^^^^^^^

Position: applies to lists of records

Values: ``array`` (default), ``table``

Semantics: ``table`` uses biniou's table format instead of a regular
array for serializing OCaml data into biniou. Both formats are supported
for reading into OCaml data regardless of the annotation. The table
format allows

Example:

.. code:: ocaml

    type item = {
      id : int;
      data : string list;
    }

    type items = item list 

Section ``ocaml``
-------------------

Field ``predef``
~~~~~~~~~~~~~~~~~~

Position: left-hand side of a type definition, after the type name

Values: none, ``true`` or ``false``

Semantics: this flag indicates that the corresponding OCaml type
definition must be omitted.

Example:

.. code:: ocaml

    (* Some third-party OCaml code *)
    type message = {
      from : string;
      subject : string;
      body : string;
    }

.. code:: ocaml

    (*
       Our own ATD file used for making message_of_string and
       string_of_message functions.
    *)
    type message  = {
      from : string;
      subject : string;
      body : string;
    }

Field ``mutable``
~~~~~~~~~~~~~~~~~~~

Position: after a record field name

Values: none, ``true`` or ``false``

Semantics: this flag indicates that the corresponding OCaml record field
is mutable.

Example:

.. code:: ocaml

    type counter = {
      total  : int;
      errors  : int;
    }

translates to the following OCaml definition:

.. code:: ocaml

    type counter = {
      mutable total : int;
      mutable errors : int;
    }

Field ``default``
~~~~~~~~~~~~~~~~~~~

Position: after a record field name marked with a ``\~{``} symbol or at
the beginning of a tuple field.

Values: any valid OCaml expression

Semantics: specifies an explicit default value for a field of an OCaml
record or tuple, allowing that field to be omitted. Default strings must
be escaped.

Example:

.. code:: ocaml

    type color = [ Black | White | Rgb of (int * int * int) ]

    type ford_t = {
      year : int;
      ~color  : color;
      ~name  : string;
    }

    type point = (int * int *  : int)

Field ``from``
~~~~~~~~~~~~~~~~

Position: left-hand side of a type definition, after the type name

Values: OCaml module name without the ``_t``, ``_b``, ``_j`` or ``_v``
suffix. This can be also seen as the name of the original ATD file,
without the ``.atd`` extension and capitalized like an OCaml module
name.

Semantics: specifies the base name of the OCaml modules where the type
and values coming with that type are defined.

It is useful for ATD types defined as ``abstract`` and for types
annotated as predefined using the annotation ````. In both
cases, the missing definitions must be provided by modules composed of
the base name and the standard suffix assumed by Atdgen which is ``_t``,
``_b``, ``_j`` or ``_v``.

Example: First input file ``part1.atd``:

.. code:: ocaml

    type point = { x : int; y : int }

Second input file ``part2.atd`` depending on the first one:

.. code:: ocaml

    type point  = abstract
    type points = point list

To use a different type name than defined in the ``Part1`` module, add a
``t`` field declaration to the annotation which refers to the original
type name:

.. code:: ocaml

    type point_xy  = abstract
    type points = point_xy list


Field ``module``
~~~~~~~~~~~~~~~~~~

Using a custom wrapper
^^^^^^^^^^^^^^^^^^^^^^

Using the built-in ``wrap`` constructor, it is possible to add a layer
of abstraction on top of the concrete structure used for serialization.

Position: after a ``wrap`` type constructor

Values: OCaml module name

A common use case is to parse strings used as unique identifiers and
wrap the result into an abstract type. Our OCaml module ``Uid`` needs to
provide a type ``t``, and two functions ``wrap`` and ``unwrap`` as
follows:

.. code:: ocaml

    type t
    val wrap : string -> t
    val unwrap : t -> string

Given that ``Uid`` OCaml module, we can write the following ATD
definition:

.. code:: ocaml

    type uid = string wrap 

Other languages than OCaml using the same ATD type definitions may or
may not add their own abstract layer. Without an annotation, the
``wrap`` construct has no effect on the value being wrapped, i.e.
``wrap`` and ``unwrap`` default to the identity function.

It is also possible to define ``t``, ``wrap``, and ``unwrap`` inline:

.. code:: ocaml

    type uid = string wrap 

This can be useful for very simple validation:

.. code:: ocaml

    type uid = string wrap
      

Importing an external type definition
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

In most cases since Atdgen 1.2.0 ``module`` annotations are deprecated
in favor of ``from`` annotations previously described.

Position: left-hand side of a type definition, after the type name

Values: OCaml module name

Semantics: specifies the OCaml module where the type and values coming
with that type are defined. It is useful for ATD types defined as
``abstract`` and for types annotated as predefined using the annotation
````. In both cases, the missing definitions can be
provided either by globally opening an OCaml module with an OCaml
directive or by specifying locally the name of the module to use.

The latter approach is recommended because it allows to create type and
value aliases in the OCaml module being generated. It results in a
complete module signature regardless of the external nature of some
items.

Example: Input file ``example.atd``:

.. code:: ocaml

    type document  = abstract

    type color  =
      [ Black | White ] 

    type point  = {
      x : float;
      y : float;
    }

gives the following OCaml type definitions (file ``example.mli``):

.. code:: ocaml

    type document = Doc.document

    type color = Color.color =  Black | White

    type point = Point.point = { x: float; y: float }

Now for instance ``Example.Black`` and ``Color.Black`` can be used
interchangeably in other modules.

Field ``t``
~~~~~~~~~~~~~

Using a custom wrapper
^^^^^^^^^^^^^^^^^^^^^^

Specifies the OCaml type of an abstract ``wrap`` construct, possibly
overriding the default *M*\ ``.t`` if *M* is the module where the
``wrap`` and ``unwrap`` functions are found.

Position: after a ``wrap`` type constructor

Values: OCaml type name

Example:

.. code:: ocaml

    type uid = string wrap 

is equivalent to:

.. code:: ocaml

    type uid = string wrap 

Importing an external type definition
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Position: left-hand side of a type definition, after the type name. Must
be used in conjunction with a ``module`` field.

Values: OCaml type name as found in an external module.

Semantics: This option allows to specify the name of an OCaml type
defined in an external module.

It is useful when the type needs to be renamed because its original name
is already in use or not enough informative. Typically we may want to
give the name ``foo`` to a type originally defined in OCaml as
``Foo.t``.

Example:

.. code:: ocaml

    type foo  = abstract
    type bar  = abstract
    type t  = abstract

allows local type names to be unique and gives the following OCaml type
definitions:

.. code:: ocaml

    type foo = Foo.t
    type bar = Bar.t
    type t = Baz.t

Fields ``wrap`` and ``unwrap``
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

See "Using a custom wrapper" under section ``ocaml``, fields
``module`` and ``t``.

Field ``field_prefix``
~~~~~~~~~~~~~~~~~~~~~~~~

Position: record type expression

Values: any string making a valid prefix for OCaml record field names

Semantics: specifies a prefix to be prepended to each field of the OCaml
definition of the record. Overridden by alternate field names defined on
a per-field basis.

Example:

.. code:: ocaml

    type point2 = {
      x : int;
      y : int;
    } 

gives the following OCaml type definition:

.. code:: ocaml

    type point2 = {
      p2_x : int;
      p2_y : int;
    }

Field ``name``
~~~~~~~~~~~~~~~~

Position: after record field name or variant name

Values: any string making a valid OCaml record field name or variant
name

Semantics: specifies an alternate record field name or variant names to
be used in OCaml.

Example:

.. code:: ocaml

    type color = [
        Black 
      | White 
      | Grey 
    ]

    type profile = {
      id  : int;
      username : string;
    }

gives the following OCaml type definitions:

.. code:: ocaml

    type color = [
        `Grey0
      | `Grey100
      | `Grey50
    ]

    type profile = {
      profile_id : int;
      username : string;
    }

Field ``repr``
~~~~~~~~~~~~~~~~

Integers
^^^^^^^^

Position: after ``int`` type

Values: ``char``, ``int32``, ``int64``, ``float``

Semantics: specifies an alternate type for representing integers. The
default type is ``int``, but ``char``, ``int32``, ``int64`` or ``float``
can be used instead.

The three types ``char``, ``int32`` and ``int64`` are supported by both
Atdgen-biniou and Atdgen-json but Atdgen-biniou currently requires that
they map to the corresponding fixed-width types provided by the biniou
format.

The type ``float`` is only supported in conjunction with JSON and is
useful when an OCaml float is used to represent an integral value, such
as a time in seconds returned by ``Unix.time()``. When converted into
JSON, floats are rounded to the nearest integer.

Example:

.. code:: ocaml

    type t = {
      id : int
        
        ;
      data : string list;
    }

Lists and arrays
^^^^^^^^^^^^^^^^

Position: after a ``list`` type

Values: ``array``

Semantics: maps to OCaml's ``array`` type instead of ``list``.

Example:

.. code:: ocaml

    type t = {
      id : int;
      data : string list
        ;
    }

Sum types
^^^^^^^^^

Position: after a sum type (denoted by square brackets)

Values: ``classic``

Semantics: maps to OCaml's classic variants instead of polymorphic
variants.

Example:

.. code:: ocaml

    type fruit = [ Apple | Orange ] 

translates to the following OCaml type definition:

.. code:: ocaml

    type fruit = Apple | Orange

Shared values (obsolete)
^^^^^^^^^^^^^^^^^^^^^^^^

Position: after a ``shared`` type

This feature is obsolete and was last supported by atdgen 1.3.1.

Field ``valid``
~~~~~~~~~~~~~~~~~

Since atdgen 1.6.0.

Position: after any type expression except type variables

Values: OCaml function that takes one argument of the given type and
returns a bool

Semantics: ``atdgen -v`` produces for each type named *t* a function
``validate_``\ *t*:

.. code:: ocaml

    val validate_t : Atdgen_runtime.Util.Validation.path -> t -> Atdgen_runtime.Util.Validation.error option

Such a function returns ``None`` if and only if the value and all of its
subnodes pass all the validators specified by annotations of the form
```` or ```` (at most one per
node).

Example:

.. code:: ocaml

    type positive = int 

    type point = {
      x : positive;
      y : positive;
      z : int;
    }
      
      (* Some validating function from a user-defined module Point *)

The generated ``validate_point`` function calls the validator for the
containing object first (``Point.validate``) and continues on its fields
``x`` then ``y`` until an error is returned.

.. code:: ocaml

    match validate_point [] { x = 1; y = 0; z = 1 } with
    | None -> ()
    | Some e ->
        Printf.eprintf "Error: %s\n%!"
          (Atdgen_runtime.Util.Validation.string_of_error e)

The above code prints the following error message:

::

    Error: Validation error; path = .y

In order to customize the error message and print the faulty value, use
``validator`` instead of ``valid``, as described next.

Field ``validator``
~~~~~~~~~~~~~~~~~~~~~

This is a variant of the ``valid`` annotation that allows full control
over the error message that gets generated in case of an error.

Position: after any type expression except type variables

Values: OCaml function that takes the path in current JSON structure and
the object to validate, and returns an optional error.

Semantics: ``atdgen -v`` produces for each type named *t* a function
``validate_``\ *t*:

.. code:: ocaml

    val validate_t : Atdgen_runtime.Util.Validation.path -> t -> Atdgen_runtime.Util.Validation.error option

Such a function returns ``None`` if and only if the value and all of its
subnodes pass all the validators specified by annotations of the form
```` or ```` (at most one per
node).

Example:

.. code:: ocaml

    type positive = int 

    type point = {
      x : positive;
      y : positive;
      z : int;
    }
      
      (* Some validating function from a user-defined module Point *)

The following user code

.. code:: ocaml

    match Toto_v.validate_point [] { x = 1; y = 0; z = 1 } with
    | None -> ()
    | Some e ->
        Printf.eprintf "Error: %s\n%!"
          (Atdgen_runtime.Util.Validation.string_of_error e)

results in printing:

::

    Error: Validation error: Not a positive integer: 0; path = .y

Section ``ocaml_biniou``
--------------------------

Section ``ocaml_biniou`` takes precedence over section ``ocaml`` in
Biniou mode (``-b``) for the following fields:

-  ``predef`` (see section ``ocaml``, field ``predef``)
-  ``module`` (see section ``ocaml``, field ``module``)
-  ``t`` (see section ``ocaml.t``)

Section ``ocaml_json`` (obsolete)
-----------------------------------

Section ``ocaml_json`` takes precedence over section ``ocaml`` in JSON
mode (``-json`` or ``-j``) for the following fields:

-  ``predef`` (see section ``ocaml``, field ``predef``)
-  ``module`` (see section ``ocaml``, field ``module``)
-  ``t`` (see section ``ocaml``, field ``t``)

Please note that ``atdgen -json`` is now deprecated in favor of
``atdgen -j`` (json) and ``atdgen -t`` (types). The latter is in charge
of producing type definitions independently from JSON and will ignore
```` annotations, making them almost useless. The
equivalent ```` annotations are almost always preferable.

Example:

This example shows how to parse a field into a generic tree of type
``Yojson.Safe.t`` rather than a value of a specialized OCaml type.

.. code:: ocaml

    type dyn  = abstract

    type t = { foo: int; bar: dyn }

translates to the following OCaml type definitions:

.. code:: ocaml

    type dyn = Yojson.Safe.t

    type t = { foo : int; bar : dyn }

Sample OCaml value of type ``t``:

.. code:: ocaml

    {
      foo = 12345;
      bar =
        `List [
          `Int 12;
          `String "abc";
          `Assoc [
            "x", `Float 3.14;
            "y", `Float 0.0;
            "color", `List [ `Float 0.3; `Float 0.0; `Float 1.0 ]
          ]
        ]
    }

Corresponding JSON data as obtained with ``string_of_t``:

::

    {"foo":12345,"bar":[12,"abc",{"x":3.14,"y":0.0,"color":[0.3,0.0,1.0]}]}

Section ``doc``
-----------------

Unlike comments, ``doc`` annotations are meant to be propagated into the
generated source code. This is useful for making generated interface
files readable without having to consult the original ATD file.

Generated source code comments can comply to a standard format and take
advantage of documentation generators such as javadoc or ocamldoc.

Field ``text``
~~~~~~~~~~~~~~~~

Position:

-  after the type name on the left-hand side of a type definition
-  after the type expression on the right hand of a type definition (but
   not after any type expression)
-  after record field names
-  after variant names

Values: UTF-8-encoded text using a minimalistic markup language

Semantics: The markup language is defined as follows:

-  Blank lines separate paragraphs.
-  ``{{ }}`` can be used to enclose inline verbatim text.
-  ``{{{ }}}`` can be used to enclose verbatim text where whitespace is
   preserved.
-  The backslash character is used to escape special character
   sequences. In regular paragraph mode the special sequences are ``\``,
   ``{{`` and ``{{{``. In inline verbatim text, special sequences are
   ``\`` and ``}}``. In verbatim text, special sequences are ``\`` and
   ``}}}``.

Example: The following is an example demonstrating the use of ``doc``
annotations generated using:

::

    $ atdgen -t ocamldoc_example.atd

Input file ``ocamldoc_example.atd``:

.. code:: ocaml

    

    type point = {
      x : float;
      y : float;
    }
      

    type color = [
     | Black 
     | White 
     | RGB
         
         of (int * int * int)
    ]

translates using ``atdgen -t ocamldoc_example.atd`` into the following
OCaml interface file ``ocamldoc_example_t.mli`` with ocamldoc-compliant
comments:

.. code:: ocaml

    (* Auto-generated from "ocamldoc_example.atd" *)


    (** This is the title *)

    (**
      The type of a point. A value [p] can be created as follows:
      
    {v
    let p = \{ x = 1.2; y = 5.0 \}
    v}
    *)
    type point = {
      x: float (** The first coordinate *);
      y: float (** The second coordinate *)
    }

    type color = [
        `Black (** Same as [RGB (0,0,0)] *)
      | `White (** Same as [RGB (255, 255, 255)] *)
      | `RGB of (int * int * int) (** Red, green, blue components *)
    ]

Atdgen runtime library
======================

A library named `atdgen-runtime `_ is installed by the standard installation
process. Only a fraction of it is officially supported and documented.

Modules intended for all users are:

-  ``Util``
-  ``Json_adapter``

The other modules exported by the library are used directly by
generated code. Tool developers may use them but we don't guarantee
strong compatibility across releases.
atd-2.1.0/doc/atdj.rst000066400000000000000000000215701357165332000145150ustar00rootroot00000000000000***************************
Java/Json support with atdj
***************************

The ATDJ tool generates a Java interface from an ATD interface. In
particular, given a set of ATD types, this tool generates a set of Java
classes representing those types. These classes may then be instantiated
from JSON representations of those same ATD types.

The primary benefits of using the generated interface, over manually
manipulating JSON strings from within Java, are safety and ease of use.
Specifically, the generated interface offers the following features:

-  JSON strings are automatically checked for correctness with respect
   to the ATD specificion.

-  Details such as optional fields and their associated default values
   are automatically handled.

-  Several utility methods are included “for free”. These support
   equality testing, the visitor pattern and conversion back to JSON.

Installation
============

Build and install the ``atdj`` command with `opam `__:

  ::

       opam install atdj

Quick-start
===========

In this section we briefly describe how to to generate a Java interface
from an example ATD file ``test.atd``. We then show how to build and run
an example application ``AtdjTest`` that uses the generated interface.

#. Generate and compile the interface:

   ::

       atdj -graph -package com.mylife.test test.atd
       export CLASSPATH='.:json.jar'
       javac com/mylife/test/*.java

#. Compile and run the example, saving the output for later inspection:

   ::

       javac AtdjTest.java
       java AtdjTest >test.out

#. Optionally, generate Javadoc documentation:

   ::

         javadoc -d doc -public com.mylife.test

   The resulting documentation is located in the directory ``doc``.

#. Optionally, generate a class graph of the generated interface:

   ::

       dot -Tpdf test.dot >test.pdf

The output file ``test.pdf`` contains a class graph of the generated
Java interface. The required ``dot`` program is part of the Graphviz
graph visualisation package, and may be downloaded from
http://www.graphviz.org/.

In the following sections we discuss the individual steps in more
detail, using the example from above.

Generating the interface
========================

In this section we describe the process of generating a Java interface
from an ATD specification.

A Java interface is generated from an ATD file as

::

    atdj -package  

This outputs a set of Java source files. The ``-package`` option causes
the resulting classes to be members of the specified package, and also
to be located in the corresponding output directory. If no package is
specified, then the default package of ``out`` is used.

For example, the command

::

    atdj -graph -package com.mylife.test test.atd

causes the generated files to be members of the package
``com.mylife.test`` and to be located in the directory
``com/mylife/test``.

The generated source files reference various members of the included
org.json package. Therefore, in order to compile the generated files,
the ``org.json`` package must be located within the Java classpath.
Supposing that the ``org.json`` package is located within the archive
``json.jar`` within the current directory, it is sufficient to set the
classpath as follows:

::

    export CLASSPATH='json.jar'

Returning to our example, the generated source files may then be
compiled as:

::

    javac com/mylife/test/*.java

Generating Javadoc documentation
================================

The generated Java code contains embedded Javadoc comments. These may be
extracted to produce Javadoc documentation. In the case of our example,
it is sufficient to run the following command:

::

      javadoc -d doc/example -public com.mylife.test

Generating a class graph
========================

We now discuss the ``-graph`` option of ATDJ. When enabled, this causes
ATDJ to output a graph of the class hierarchy of the generated code. The
output is intended to document the generated code, helping users to
avoid consulting the source code.

Continuing with our example, the use of this option results in the
generation of an additional output file named ``test.dot``. Assuming
that the ``dot`` program is installed, a PDF class graph named
``test.pdf`` can then created by running the command

::

    dot -Tpdf test.dot >test.pdf

In the generated class graph, rectangular and oval nodes correspond to
classes and interfaces, respectively. Field names are specified in the
second line of retangular (class) nodes. Solid arcs denote subtyping
(``implements``/``extends``), whilst dashed arcs link fields to their
types.

Translation reference
=====================

In this section we informally define how Java types are generated from
ATD types.

Bools, ints, floats, string, lists
----------------------------------

+---------------+------------------+
| ATD type, t   | Java type,    |
+===============+==================+
| bool          | boolean          |
+---------------+------------------+
| int           | int              |
+---------------+------------------+
| float         | double           |
+---------------+------------------+
| string        | String           |
+---------------+------------------+
| t list        | []            |
+---------------+------------------+

Options
-------

Suppose that we have ATD type ``t option``. Then this is translated into
the following Java reference type:

::

    public class CNAME implements Atdj {
      // Constructor
      public CNAME(String s) throws JSONException { ... }

    // Get the optional value, if present
    public CNAME get() throws JSONException     { ... }

    // Comparison and equality
    public int     compareTo(CNAME that)        { ... }
    public boolean equals(CNAME that)           { ... }

    public  value;           // The value
    public boolean is_set;      // Whether the value is set
    }

Records
-------

Suppose that we have the ATD record type

::

    { f_1: t_1
    ;  ...
    ; f_n: t_n
    }

Then this is translated into the following Java reference type:

::

    public class CNAME implements Atdj {
      // Constructor
      public CNAME(String s) throws JSONException { ... }

    // Comparison and equality
    public int     compareTo(CNAME that)        { ... }
    public boolean equals(CNAME that)           { ... }

    // The individual fields
    public  f_1;
    ...
    public  f_n;
    }

An optional field ``~f_i: t_i`` causes the class field ``f_i`` to be
given a default value of type ```` if the field is absent from the
JSON string used to instantiate the class. The default values are as
follows:

+------------+---------------------------------------+
| ATD type   | Default Java value                    |
+============+=======================================+
| bool       | false                                 |
+------------+---------------------------------------+
| int        | 0                                     |
+------------+---------------------------------------+
| float      | 0.0                                   |
+------------+---------------------------------------+
| string     | “”                                    |
+------------+---------------------------------------+
| t list     | Empty array                           |
+------------+---------------------------------------+
| t option   | Optional value with is\_set = false   |
+------------+---------------------------------------+

Default values cannot be defined for record and sum types.

An optional field ``?f_i: t_i option`` has the same default behaviour as
above, with the additional behaviour that if the field is present in the
JSON string then the value must be of type  (not  option); the
value is then automatically lifted into a  option, with is\_set =
true.

Sums
----

Suppose that we have the ATD sum type

::

    [ C_1 of t_1
    | ...
    | C_n of t_n
    ]

Then this is translated into the following Java reference types:

::

    public interface IFCNAME extends Atdj {
      public int     compareTo(IFCNAME that);
      public boolean equals(IFCNAME that);
      ...
    }

::

    public class CNAME_i implements IFCNAME, Atdj {
      // Comparison and equality
      public int     compareTo(CNAME that)        { ... }
      public boolean equals(CNAME that)           { ... }

    public  value;
    }

The value field is absent if the constructor C\_i has no argument.

The Atdj and Visitor interfaces
-------------------------------

All generated reference types additionally implement the interface

::

    interface Atdj {
      String toString();
      String toString(int indent);
      int hashCode();
      Visitor accept(Visitor v);
    }

where the Visitor interface is defined as

::

    public interface Visitor {
      public void visit(CNAME_1 value);
      ...
      public void visit(CNAME_n value);
    }

for generated reference types ``CNAME``\ \_i. Visit methods for
primitive and optional primitive types are omitted.
atd-2.1.0/doc/biniou-format.txt000066400000000000000000000120611357165332000163500ustar00rootroot00000000000000                              The Biniou format
                              -----------------

Contents:

1. Grammar
2. Tags
3. Fixed-length types
4. Vints
5. Field and variant name hashing
6. Numeric variants



1. Grammar


  TAGVAL ::= TAG VAL    // A biniou value with its matching tag

  VAL ::= ATOM
        | ARRAY
        | TUPLE
        | RECORD
        | NUM_VARIANT
        | VARIANT
        | TABLE
        | SHARED

  ATOM ::= unit     // 0, using one byte
         | bool     // 0 for false, 1 for true, using one byte
         | int8     // 1 arbitrary byte
         | int16    // 2 arbitrary bytes
         | int32    // 4 arbitrary bytes
         | int64    // 8 arbitrary bytes
         | float64  // IEEE-754 binary64
         | uvint    // unsigned variable-length int
         | svint    // signed variable-length int
         | string   // sequence of any number of bytes

  ARRAY ::= LENGTH (TAG VAL* )?
  NUM_VARIANT ::= NUM_VARIANT_TAG TAGVAL?
  VARIANT ::= VARIANT_TAG TAGVAL?
  TUPLE ::= LENGTH TAGVAL*
  RECORD ::= LENGTH (FIELD_TAG TAGVAL)*
  TABLE ::= LENGTH (LENGTH (FIELD_TAG TAG)* (VAL* )* )? // list of records

  SHARED ::= OFFSET TAGVAL?  // Value given iff the offset is 0.
                             // Otherwise, the offset indicates the 
                             // relative position to the left of a SHARED
                             // to which we are redirected.

  TAG ::= int8               // identifies a type of node
  LENGTH ::= uvint
  OFFSET ::= uvint
  NUM_VARIANT_TAG ::= int8   // 0-127 if no argument, 128-255 if has argument
  VARIANT_TAG ::= int32      // first bit indicates argument, then 31-bit hash
  FIELD_TAG ::= int32        // 31-bit hash (first bit always 1)



2. Tags


Tags indicate the shallow structure of any biniou value.

The biniou format is such that the tag of any value is known
from the input data.  This allows decoding biniou data as a tree
where each node represents a biniou value, without requiring external 
type information.

The tag values for the various kinds of biniou values are:

    Type of value     Tag    
    ---------------------------
    bool              0
    int8              1
    int16             2
    int32             3
    int64             4
    float64           12
    uvint             16
    svint             17
    string            18
    ARRAY             19
    TUPLE             20
    RECORD            21
    NUM_VARIANT       22
    VARIANT           23
    unit              24
    TABLE             25
    SHARED            26



3. Fixed-length types


Atomic values of type unit, bool, int8, int16, int32, int64 and float64 
represent arbitrary sequences of 1, 2, 4 or 8 bytes.

In order to make the visualization of data easier,
the default interpretation of these values shall be used:

    Length
    in bytes   Type of value   Default interpretation
    ---------------------------------------------------------------------
    1          unit            0 represents the unit value
    1          bool            0 represents false, 1 represents true
    1          int8            unsigned 8-bit int
    2          int16           big endian unsigned 16-bit int
    4          int32           big endian unsigned 32-bit int
    8          int64           big endian unsigned 64-bit int
    8          float64         big endian IEEE-754 binary64 (double)



4. Vints


Vints are a variable-length, byte-aligned representation of
positive integers.  

A vint is represented by a sequence of bytes from least significant
to most significant.  In all the bytes except the last one, the
high bit is set to 1 and indicates that more bytes follow.
The high bit of the last byte is set to 0.
The remaining 7 bits in each byte represent data.

Here is the representation of some sample values:

           0xxxxxxx
  0        00000000
  1        00000001
  2        00000010
  127      01111111

           1xxxxxxx 0xxxxxxx
  128      10000000 00000001
  129      10000001 00000001
  255      11111111 00000001
  256      11111111 00000010
  16383    11111111 01111111

           1xxxxxxx 1xxxxxxx 0xxxxxxx
  16384    10000000 10000000 00000001
  16385    10000001 10000000 00000001


Positive integers can be represented by standard vints.
We call this representation unsigned vint or uvint.

Arbitrary integers can also be represented using vints, after mapping
to positive integers.  We call this representation signed vint or svint.
Positive numbers and 0 are mapped to even numbers and negative numbers
are mapped to odd positive numbers.  Here is the mapping for
small numbers:

    vint              unsigned	            signed        
    representation    interpretation	    interpretation
		      (uvint)               (svint)	
    0xxxxxx0
    00000000          0	             	    0
    00000010          2	             	    1
    00000100          4	                    2
    00000110          6	                    3

    0xxxxxx1					
    00000001          1	                    -1
    00000011          3	                    -2
    00000101          5                     -3



5. Field and variant name hashing


atd-2.1.0/doc/conf.py000066400000000000000000000105651357165332000143420ustar00rootroot00000000000000#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#
# This file is execfile()d with the current directory set to its
# containing dir.
#
# Note that not all possible configuration values are present in this
# autogenerated file.
#
# All configuration values have a default; values that are commented out
# serve to show the default.

# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
#
# import os
# import sys
# sys.path.insert(0, os.path.abspath('.'))


# -- General configuration ------------------------------------------------

# If your documentation needs a minimal Sphinx version, state it here.
#
# needs_sphinx = '1.0'

# Add any Sphinx extension module names here, as strings. They can be
# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
# ones.
extensions = []

# Add any paths that contain templates here, relative to this directory.
templates_path = ['_templates']

# The suffix(es) of source filenames.
# You can specify multiple suffix as a list of string:
#
# source_suffix = ['.rst', '.md']
source_suffix = '.rst'

# The master toctree document.
master_doc = 'index'

# General information about the project.
project = 'atd'
copyright = u'2010-2012 MyLife; 2012-2018 Martin Jambon & contributors'
author = u'Martin Jambon, John Billings & contributors'

# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
#
# This is also used if you do content translation via gettext catalogs.
# Usually you set "language" from the command line for these cases.
language = None

# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
# This patterns also effect to html_static_path and html_extra_path
exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']

# The name of the Pygments (syntax highlighting) style to use.
pygments_style = 'sphinx'

# If true, `todo` and `todoList` produce output, else they produce nothing.
todo_include_todos = False


# -- Options for HTML output ----------------------------------------------

# The theme to use for HTML and HTML Help pages.  See the documentation for
# a list of builtin themes.
#
html_theme = 'sphinx_rtd_theme'

# Theme options are theme-specific and customize the look and feel of a theme
# further.  For a list of options available for each theme, see the
# documentation.
#
html_theme_options = {'navigation_depth': 6}

# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
# html_static_path = ['_static']


# -- Options for HTMLHelp output ------------------------------------------

# Output file base name for HTML help builder.
htmlhelp_basename = 'atddoc'


# -- Options for LaTeX output ---------------------------------------------

latex_elements = {
    # The paper size ('letterpaper' or 'a4paper').
    #
    # 'papersize': 'letterpaper',

    # The font size ('10pt', '11pt' or '12pt').
    #
    # 'pointsize': '10pt',

    # Additional stuff for the LaTeX preamble.
    #
    # 'preamble': '',

    # Latex figure (float) alignment
    #
    # 'figure_align': 'htbp',
}

# Grouping the document tree into LaTeX files. List of tuples
# (source start file, target name, title,
#  author, documentclass [howto, manual, or own class]).
latex_documents = [
    (master_doc, 'atd.tex', 'atd Documentation',
     u'Martin Jambon', 'manual'),
]


# -- Options for manual page output ---------------------------------------

# One entry per manual page. List of tuples
# (source start file, name, description, authors, manual section).
man_pages = [
    (master_doc, 'atd', 'atd Documentation',
     [author], 1)
]


# -- Options for Texinfo output -------------------------------------------

# Grouping the document tree into Texinfo files. List of tuples
# (source start file, target name, title, author,
#  dir menu entry, description, category)
texinfo_documents = [
    (master_doc, 'atd', 'atd Documentation',
     author, 'atd', 'One line description of project.',
     'Miscellaneous'),
]



import sphinx_rtd_theme

html_theme_path = [sphinx_rtd_theme.get_html_theme_path()]
atd-2.1.0/doc/index.rst000066400000000000000000000002071357165332000146740ustar00rootroot00000000000000Welcome to ATD's documentation!
===============================

.. toctree::
   :maxdepth: 3

   tutorial
   syntax
   atdgen
   atdj
atd-2.1.0/doc/syntax.rst000066400000000000000000000424441357165332000151240ustar00rootroot00000000000000*************************
ATD core syntax reference
*************************

Introduction
============

ATD stands for Adjustable Type Definitions.

.. code-block:: ocaml

  (* This is a sample ATD file *)

  type profile = {
    id : string;
    email : string;
    ~email_validated : bool;
    name : string;
    ?real_name : string option;
    ~about_me : string list;
    ?gender : gender option;
    ?date_of_birth : date option;
  }

  type gender = [ Female | Male ]

  type date = {
    year : int;
    month : int;
    day : int;
  }

ATD is a language for defining data types across multiple programming languages
and multiple data formats. That's it.

We provide an OCaml library that provides a parser and a collection of tools
that make it easy to write data validators and code generators based on ATD
definitions.

Unlike big frameworks that provide everything in one monolithic package, we
split the problem of data exchange into logical modules and ATD is one of them.
In particular, we acknowledge that the following pieces have little in common
and should be defined and implemented separately:


* data type specifications
* transport protocols
* serialization formats

Ideally we want just one single language for defining data types and it should
accomodate all programming languages and data formats. ATD can play this role,
but its OCaml implementation makes it particularly easy to translate ATD
specifications into other interface definition languages if needed.

It is however much harder to imagine that a single transport protocol and a
single serialization format would ever become the only ones used. A reader from
the future might wonder why we are even considering defining a transport
protocol and a serialization format together. This has been a widespread
practice at least until the beginning of the 21st century (ONC RPC, ICE, Thrift,
etc.). For mysterious reasons, people somehow became convinced that calls to
remote services should be made to mimic internal function calls, pretending that
nothing really bad could happen on the way between the caller and the remote
service. Well, I don't let my 3-old daughter go to school by herself because the
definition of the external world is precisely that it is unsafe.

Data input is by definition unsafe. A program whose internal data is corrupted
should abort but a failed attempt to read external data should not cause a
program to abort. On the contrary, a program should be very resistent to all
forms of data corruption and attacks and provide the best diagnosis possible
when problems with external data occur.

Because data exchange is critical and involves multiple partners, we depart from
magic programming language-centric or company-centric approaches. We define ATD,
a data type definition language designed for maximum expressivity, compatibility
across languages and static type checking of programs using such data.

Scope
-----

ATD offers a core syntax for type definitions, i.e. an idealized view of the
structure of data. Types are mapped to each programming language or data format
using language-specific conventions. Annotations can complete the type
definitions in order to specify options for a particular language. Annotations
are placed in angle brackets after the element they refer to:

.. code-block:: ocaml

  type profile = {
    id : int ;
      (*
        An int here will map to an OCaml int64 instead of
        OCaml's default int type.
        Other languages than OCaml will use their default int type.
      *)

    age : int;
      (* No annotation here, the default int type will be used. *)
  }

ATD supports:

* the following atomic types: bool, int, float, string and unit;
* built-in list and option types;
* records aka structs with a syntax for optional fields with or
  without default;
* tuples;
* sum types aka variant types, algebraic data types or tagged unions;
* parametrized types;
* inheritance for both records and sum types;
* abstract types;
* arbitrary annotations.


ATD by design does not support:

* function types, function signatures or method signatures;
* a syntax to represent values;
* a syntax for submodules.

Language overview
-----------------

ATD was strongly inspired by the type system of ML and OCaml. Such a
type system allows static type checking and type inference, properties
which contribute to the safety and conciseness of the language.

Unlike mainstream languages like Java, C++, C# or Python to name a
few, languages such as Haskell or OCaml offer sum types,
also known as algebraic data types or variant types. These allow to
specify that an object is of one kind or another without ever
performing dynamic casts.

.. code-block:: ocaml

  (* Example of a sum type in ATD. The vertical bar reads `or'. *)
  type shape = [
      Square of float               (* argument: side length *)
    | Rectangle of (float * float)  (* argument: width and height *)
    | Circle of float               (* argument: radius *)
    | Dot                           (* no argument *)
  ]

A notable example of sum types is the predefined option type.
An object of an option type contains either one value of a given type
or nothing. We could define our own `int_option` type as follows:

.. code-block:: ocaml

  type int_option = [ None | Some of int ]

ATD supports parametrized types also known as generics in Java or
templates in C++.  We could define our own generic option type as
follows:

.. code-block:: ocaml

  type 'a opt = [ None | Some of 'a ]
    (* 'a denotes a type parameter. *)

  type opt_int = int opt
    (* equivalent to int_option defined in the previous example *)

  type opt_string = string opt
    (* same with string instead of int *)

In practice we shall use the predefined option type.
The option type is fundamentally different from nullable objects since
the latter don't allow values that would have type `'a option option`.

ATD also support product types. They come in two forms: tuples and
records:

.. code-block:: ocaml

  type tuple_example = (string * int)

  type record_example = {
    name : string;
    age : int;
  }

Although tuples in theory are not more expressive than records, they are much
more concise and languages that support them natively usually do not require
type definitions.

Finally, ATD supports multiple inheritance which is a simple mechanism for
adding fields to records or variants to sum types:

.. code-block:: ocaml

  type builtin_color = [
      Red | Green | Blue | Yellow
    | Purple | Black | White
  ]

  type rgb = (float * float * float)
  type cmyk = (float * float * float * float)

  (* Inheritance of variants *)
  type color = [
      inherit builtin_color
    | Rgb of rgb
    | Cmyk of cmyk
  ]

.. code-block:: ocaml

  type basic_profile = {
    id : string;
    name : string;
  }

  (* Inheritance of record fields *)
  type full_profile = {
    inherit basic_profile;
    date_of_birth : (int * int * int) option;
    street_address1 : string option;
    street_address2 : string option;
    city : string option;
    zip_code : string option;
    state : string option;
  }


Editing and validating ATD files
--------------------------------

The extension for ATD files is ``.atd``. Editing ATD files is best achieved
using an OCaml-friendly editor since the ATD syntax is vastly compatible with
OCaml and uses a subset of OCaml's keywords.

Emacs users can use caml-mode or tuareg-mode to edit ATD files. Adding the
following line to the ``~/.emacs`` file will automatically use tuareg-mode when
opening a file with a ``.atd`` extension:

.. code-block:: lisp

  (add-to-list 'auto-mode-alist '("\\.atd\\'" . tuareg-mode))

The syntax of an ATD file can be checked with the program ``atdcat`` provided with
the OCaml library ``atd``. ``atdcat`` pretty-prints its input data, optionally after
some transformations such as monomorphization or inheritance. Here is the output
of ``atdcat -help``:

::

  Usage: atdcat FILE
    -x 
            make type expressions monomorphic
    -xk 
            keep parametrized type definitions and imply -x.
            Default is to return only monomorphic type definitions
    -xd 
            debug mode implying -x
    -i 
            expand all `inherit' statements
    -if 
            expand `inherit' statements in records
    -iv 
            expand `inherit' statements in sum types
    -ml 
            output the ocaml code of the ATD abstract syntax tree
    -html-doc 
            replace directly  by (*html ... *)
            or replace  by (*html ... *)
            where the contents are formatted as HTML
            using